{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 如何将pyg和fastai结合起来呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 引入库区"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai import *\n",
    "from fastai.basic_data import *\n",
    "from fastai.torch_core import *\n",
    "from fastai.data_block import *\n",
    "from fastai.data_block import PreProcessors\n",
    "import torch_geometric\n",
    "import torch\n",
    "from fastai.basic_train import *\n",
    "\n",
    "import torch.nn.functional as F\n",
    "from torch.nn import Linear\n",
    "from torch_geometric.nn import GCNConv, global_mean_pool, JumpingKnowledge\n",
    "from torch_geometric.datasets import TUDataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 自己写的函数区"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义自己的网络模型\n",
    "class GCN(torch.nn.Module):\n",
    "    def __init__(self, dataset, num_layers, hidden):\n",
    "        super(GCN, self).__init__()\n",
    "        self.conv1 = GCNConv(dataset.num_features, hidden)\n",
    "        self.convs = torch.nn.ModuleList()\n",
    "        for i in range(num_layers - 1):\n",
    "            self.convs.append(GCNConv(hidden, hidden))\n",
    "        self.lin1 = Linear(hidden, hidden)\n",
    "        self.lin2 = Linear(hidden, dataset.num_classes)\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        self.conv1.reset_parameters()\n",
    "        for conv in self.convs:\n",
    "            conv.reset_parameters()\n",
    "        self.lin1.reset_parameters()\n",
    "        self.lin2.reset_parameters()\n",
    "\n",
    "    def forward(self, data):\n",
    "        x, edge_index, batch = data.x, data.edge_index, data.batch\n",
    "        x = F.relu(self.conv1(x, edge_index))\n",
    "        for conv in self.convs:\n",
    "            x = F.relu(conv(x, edge_index))\n",
    "        x = global_mean_pool(x, batch)\n",
    "        x = F.relu(self.lin1(x))\n",
    "        x = F.dropout(x, p=0.5, training=self.training)\n",
    "        x = self.lin2(x)\n",
    "        return F.log_softmax(x, dim=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 试验区"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据下载"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://ls11-www.cs.tu-dortmund.de/people/morris/graphkerneldatasets/MUTAG.zip\n",
      "Extracting ./MUTAG.zip\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "dataset = TUDataset('./', 'MUTAG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MUTAG(188)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data(edge_attr=[38, 4], edge_index=[2, 38], x=[17, 7], y=[1])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "@Time    :2019/12/22 11:44\n",
    "@Author  : 梁家熙\n",
    "@Email:  :11849322@mail.sustech.edu.cn\n",
    "\"\"\"\n",
    "import json\n",
    "import networkx as nx\n",
    "from fastai.data_block import PreProcessors\n",
    "from fastai.vision import Image, open_image\n",
    "from torch_geometric.data import Data\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "from pprint import pprint\n",
    "import os\n",
    "import collections\n",
    "from typing import List, Dict, Tuple\n",
    "import logging\n",
    "from fastai import *\n",
    "from fastai.basic_data import *\n",
    "from fastai.torch_core import *\n",
    "from fastai.data_block import *\n",
    "import torch_geometric\n",
    "logger = logging.getLogger(__name__)\n",
    "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n",
    "import torch\n",
    "import matplotlib.image as mpimg # mpimg 用于读取图片\n",
    "\n",
    "\n",
    "class MyBatch(torch_geometric.data.Batch):\n",
    "    def to(self, device, **kwargs):\n",
    "        t = self.apply(lambda x: x.to(device))\n",
    "        return t\n",
    "\n",
    "\n",
    "class GraphDataBunch(DataBunch):\n",
    "    @classmethod\n",
    "    def create(cls, train_ds:Dataset, valid_ds:Dataset, test_ds:Optional[Dataset]=None, path:PathOrStr='.', bs:int=64,\n",
    "               val_bs:int=None, num_workers:int=defaults.cpus, dl_tfms:Optional[Collection[Callable]]=None,\n",
    "               device:torch.device=None, collate_fn:Callable=data_collate, no_check:bool=False, **dl_kwargs) ->'DataBunch':\n",
    "        \"Create a `DataBunch` from `train_ds`, `valid_ds` and maybe `test_ds` with a batch size of `bs`. Passes `**dl_kwargs` to `DataLoader()`\"\n",
    "        datasets = cls._init_ds(train_ds, valid_ds, test_ds)\n",
    "        val_bs = ifnone(val_bs, bs)\n",
    "        dls = [torch_geometric.data.DataLoader(d, b, shuffle=s) for d,b,s in\n",
    "               zip(datasets, (bs,val_bs,val_bs,val_bs), (True,False,False,False)) if d is not None]\n",
    "        return cls(*dls, path=path, device=device, dl_tfms=dl_tfms, collate_fn=collate_fn, no_check=no_check)\n",
    "\n",
    "    # def one_batch(self, ds_type:DatasetType=DatasetType.Train, detach:bool=True, denorm:bool=True, cpu:bool=True)->Collection[Tensor]:\n",
    "    #     \"Get one batch from the data loader of `ds_type`. Optionally `detach` and `denorm`.\"\n",
    "    #     x, y = zip(*self.train_ds[:64])\n",
    "    #\n",
    "    #     if detach: x,y = to_detach(x,cpu=cpu),to_detach(y,cpu=cpu)\n",
    "    #     norm = getattr(self,'norm',False)\n",
    "    #     if denorm and norm:\n",
    "    #         x = self.denorm(x)\n",
    "    #         if norm.keywords.get('do_y',False): y = self.denorm(y, do_x=True)\n",
    "    #     return x,y\n",
    "\n",
    "    def show_batch(self, rows:int=5, ds_type:DatasetType=DatasetType.Train, reverse:bool=False, **kwargs)->None:\n",
    "        \"Show a batch of data in `ds_type` on a few `rows`.\"\n",
    "        x,y = self.one_batch(ds_type, True, True)\n",
    "\n",
    "        if reverse: x,y = x.flip(0),y.flip(0)\n",
    "        n_items = rows **2 if self.train_ds.x._square_show else rows\n",
    "        if self.dl(ds_type).batch_size < n_items: n_items = self.dl(ds_type).batch_size\n",
    "        x = x.to_data_list()\n",
    "\n",
    "        xs = [self.train_ds.x.reconstruct(x[i]) for i in range(n_items)]\n",
    "        #TODO: get rid of has_arg if possible\n",
    "        if has_arg(self.train_ds.y.reconstruct, 'x'):\n",
    "            ys = [self.train_ds.y.reconstruct(grab_idx(y, i), x=x) for i,x in enumerate(xs)]\n",
    "        else : ys = [self.train_ds.y.reconstruct(y[i].data) for i in range(n_items)]\n",
    "        self.train_ds.x.show_xys(xs, ys, **kwargs)\n",
    "\n",
    "class GraphList(ItemList):\n",
    "    _bunch = GraphDataBunch\n",
    "    def __init__(self, items: Iterator, path: PathOrStr = '.', label_cls: Callable = None, inner_df: Any = None,\n",
    "                 processor: PreProcessors = None, x: 'ItemList' = None, ignore_empty: bool = False):\n",
    "        self.path = Path(path)\n",
    "        self.num_parts = len(self.path.parts)\n",
    "        self.items, self.x, self.ignore_empty = items, x, ignore_empty\n",
    "        # if not isinstance(self.items, np.ndarray): self.items = array(self.items, dtype=object)\n",
    "        self.label_cls, self.inner_df, self.processor = ifnone(label_cls, self._label_cls), inner_df, processor\n",
    "        self._label_list, self._split = LabelList, ItemLists\n",
    "        self.copy_new = ['x', 'label_cls', 'path']\n",
    "        # self.items = array([(w) for w in self.items])\n",
    "\n",
    "    def split_none(self):\n",
    "        return self._split(self.path, self, ItemList([], ignore_empty=True))\n",
    "\n",
    "    def reconstruct(self, t:Tensor, x:Tensor=None):\n",
    "        edges = list([(a.item(), b.item()) for a, b in zip(t.edge_index[0], t.edge_index[1])])\n",
    "        G = nx.DiGraph()\n",
    "        G.add_edges_from(\n",
    "            edges)\n",
    "        G = G.to_undirected()\n",
    "        pos = nx.spring_layout(G, seed=0)\n",
    "        nx.draw_networkx_nodes(G, pos, cmap=plt.get_cmap('jet'),\n",
    "                               node_color='b',\n",
    "                               alpha=0.3,\n",
    "                               node_size=500)\n",
    "\n",
    "        nx.draw_networkx_labels(G, pos)\n",
    "        nx.draw_networkx_edges(G, pos,\n",
    "                               edge_color='gray',\n",
    "                               # edge_cmap=plt.cm.Blues,\n",
    "                               # edge_cmap=plt.get_cmap(),\n",
    "                               alpha=0.8,\n",
    "                               width=0.2,\n",
    "                               # arrows=True,\n",
    "                               )\n",
    "        img = plt.savefig('t.png')\n",
    "        # (640, 4, 480)\n",
    "        img = open_image('t.png')\n",
    "\n",
    "        plt.close()\n",
    "        return img\n",
    "\n",
    "    def show_xys(self, xs, ys, figsize: Tuple[int, int] = (9, 10), **kwargs):\n",
    "        \"Show the `xs` and `ys` on a figure of `figsize`. `kwargs` are passed to the show method.\"\n",
    "        rows = int(math.sqrt(len(xs)))\n",
    "        fig, axs = plt.subplots(rows, rows, figsize=figsize)\n",
    "        for i, ax in enumerate(axs.flatten() if rows > 1 else [axs]):\n",
    "            xs[i].show(ax=ax, y=ys[i], **kwargs)\n",
    "        plt.tight_layout()\n",
    "\n",
    "    def show_xyzs(self, xs, ys, zs, figsize: Tuple[int, int] = None, **kwargs):\n",
    "        \"\"\"Show `xs` (inputs), `ys` (targets) and `zs` (predictions) on a figure of `figsize`.\n",
    "        `kwargs` are passed to the show method.\"\"\"\n",
    "        figsize = ifnone(figsize, (6, 3 * len(xs)))\n",
    "        fig, axs = plt.subplots(len(xs), 2, figsize=figsize)\n",
    "        fig.suptitle('Ground truth / Predictions', weight='bold', size=14)\n",
    "        for i, (x, y, z) in enumerate(zip(xs, ys, zs)):\n",
    "            x.show(ax=axs[i, 0], y=y, **kwargs)\n",
    "            x.show(ax=axs[i, 1], y=z, **kwargs)\n",
    "            \n",
    "    def split_by_rand_pct(self, valid_pct:float=0.2, seed:int=None)->'ItemLists':\n",
    "        \"Split the items randomly by putting `valid_pct` in the validation set, optional `seed` can be passed.\"\n",
    "        if valid_pct==0.: return self.split_none()\n",
    "        if seed is not None: np.random.seed(seed)\n",
    "        rand_idx = torch.tensor(np.random.permutation(range_of(self))).long()\n",
    "        cut = int(valid_pct * len(self))\n",
    "        assert isinstance(rand_idx, torch.Tensor)\n",
    "        return self.split_by_idx(rand_idx[:cut])\n",
    "\n",
    "    def split_by_idx(self, valid_idx:Collection[int])->'ItemLists':\n",
    "        \"Split the data according to the indexes in `valid_idx`.\"\n",
    "        #train_idx = [i for i in range_of(self.items) if i not in valid_idx]\n",
    "        train_idx = torch.tensor(np.setdiff1d(arange_of(self.items), valid_idx)).long()\n",
    "        return self.split_by_idxs(train_idx, valid_idx)\n",
    "# class GraphDataBunch(DataBunch):\n",
    "class GraphLearner(Learner):\n",
    "    \n",
    "    def show_results(self, ds_type=DatasetType.Valid, rows:int=5, **kwargs):\n",
    "        \"Show `rows` result of predictions on `ds_type` dataset.\"\n",
    "        #TODO: get read of has_arg x and split_kwargs_by_func if possible\n",
    "        #TODO: simplify this and refactor with pred_batch(...reconstruct=True)\n",
    "        n_items = rows ** 2 if self.data.train_ds.x._square_show_res else rows\n",
    "        if self.dl(ds_type).batch_size < n_items: n_items = self.dl(ds_type).batch_size\n",
    "        ds = self.dl(ds_type).dataset\n",
    "        self.callbacks.append(RecordOnCPU())\n",
    "        preds = self.pred_batch(ds_type)\n",
    "        *self.callbacks,rec_cpu = self.callbacks\n",
    "        x,y = rec_cpu.input,rec_cpu.target\n",
    "        norm = getattr(self.data,'norm',False)\n",
    "        if norm:\n",
    "            x = self.data.denorm(x)\n",
    "            if norm.keywords.get('do_y',False):\n",
    "                y     = self.data.denorm(y, do_x=True)\n",
    "                preds = self.data.denorm(preds, do_x=True)\n",
    "        analyze_kwargs,kwargs = split_kwargs_by_func(kwargs, ds.y.analyze_pred)\n",
    "        x = x.to_data_list()\n",
    "        preds = [ds.y.analyze_pred(grab_idx(preds, i), **analyze_kwargs) for i in range(n_items)]\n",
    "        xs = [ds.x.reconstruct(x[i]) for i in range(n_items)]\n",
    "        if has_arg(ds.y.reconstruct, 'x'):\n",
    "            ys = [ds.y.reconstruct(grab_idx(y, i), x=x) for i,x in enumerate(xs)]\n",
    "            zs = [ds.y.reconstruct(z, x=x) for z,x in zip(preds,xs)]\n",
    "        else :\n",
    "            ys = [ds.y.reconstruct(grab_idx(y, i)) for i in range(n_items)]\n",
    "            zs = [ds.y.reconstruct(z) for z in preds]\n",
    "        ds.x.show_xyzs(xs, ys, zs, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "@Time    :2019/12/22 12:04\n",
    "@Author  : 梁家熙\n",
    "@Email:  :11849322@mail.sustech.edu.cn\n",
    "\"\"\"\n",
    "import json\n",
    "\n",
    "from fastai.basic_train import Learner\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "from pprint import pprint\n",
    "import os\n",
    "import collections\n",
    "from typing import List, Dict, Tuple\n",
    "import logging\n",
    "import torch\n",
    "import os.path as osp\n",
    "from fastai.data_block import PreProcessors\n",
    "from torch_geometric.data import Data\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "from pprint import pprint\n",
    "import os\n",
    "import collections\n",
    "from typing import List, Dict, Tuple\n",
    "import logging\n",
    "from fastai import *\n",
    "from fastai.basic_data import *\n",
    "from fastai.torch_core import *\n",
    "from fastai.data_block import *\n",
    "import torch_geometric\n",
    "import torch\n",
    "\n",
    "from torch_geometric.datasets import TUDataset\n",
    "from torch_geometric.utils import degree\n",
    "import torch_geometric.transforms as T\n",
    "import urllib\n",
    "logger = logging.getLogger(__name__)\n",
    "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n",
    "\n",
    "class NormalizedDegree(object):\n",
    "    def __init__(self, mean, std):\n",
    "        self.mean = mean\n",
    "        self.std = std\n",
    "\n",
    "    def __call__(self, data):\n",
    "        deg = degree(data.edge_index[0], dtype=torch.float)\n",
    "        deg = (deg - self.mean) / self.std\n",
    "        data.x = deg.view(-1, 1)\n",
    "        return data\n",
    "\n",
    "def get_dataset(name, myown = False, sparse=True):\n",
    "\n",
    "    # 满足TUDataset接口的数据\n",
    "    dataset = TUDataset('./', name)\n",
    "\n",
    "\n",
    "    assert dataset is not None and len(dataset) != 0\n",
    "    # 边属性 为NOne\n",
    "    dataset.data.edge_attr = None\n",
    "\n",
    "    # x属性是什么\n",
    "    if dataset.data.x is None:\n",
    "        max_degree = 0\n",
    "        degs = []\n",
    "        for data in dataset:\n",
    "            # 列表添加\n",
    "            degs += [degree(data.edge_index[0], dtype=torch.long)]\n",
    "            max_degree = max(max_degree, degs[-1].max().item())\n",
    "\n",
    "        # 最大度小于 1000 时\n",
    "        if max_degree < 1000:\n",
    "            # 转换成onehot形式\n",
    "            dataset.transform = T.OneHotDegree(max_degree)\n",
    "        else:\n",
    "            deg = torch.cat(degs, dim=0).to(torch.float)\n",
    "            mean, std = deg.mean().item(), deg.std().item()\n",
    "            dataset.transform = NormalizedDegree(mean, std) # 标准化\n",
    "\n",
    "\n",
    "    # 如果是 []对的形式,则转换成 adj的形式\n",
    "    if not sparse:\n",
    "        num_nodes = max_num_nodes = 0\n",
    "        for data in dataset:\n",
    "            num_nodes += data.num_nodes\n",
    "            max_num_nodes = max(data.num_nodes, max_num_nodes)\n",
    "\n",
    "        # Filter out a few really large graphs in order to apply DiffPool.\n",
    "        if name == 'REDDIT-BINARY':\n",
    "            num_nodes = min(int(num_nodes / len(dataset) * 1.5), max_num_nodes)\n",
    "        else:\n",
    "            num_nodes = min(int(num_nodes / len(dataset) * 5), max_num_nodes) # 设置成了 28, 因为 max_num_nodes = 28\n",
    "\n",
    "        indices = []\n",
    "        for i, data in enumerate(dataset):\n",
    "            # 找到那些数量小于 num_nodes的 图(存储index)\n",
    "            if data.num_nodes <= num_nodes:\n",
    "                indices.append(i)\n",
    "        dataset = dataset[torch.tensor(indices)]\n",
    "\n",
    "        if dataset.transform is None:\n",
    "            dataset.transform = T.ToDense(num_nodes) # 将数据设置为dense 模式 这个变换很好玩,要记住.\n",
    "        else:\n",
    "            dataset.transform = T.Compose(\n",
    "                [dataset.transform, T.ToDense(num_nodes)])\n",
    "\n",
    "    return dataset\n",
    "\n",
    "\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch.nn import Linear\n",
    "from torch_geometric.nn import GCNConv, global_mean_pool, JumpingKnowledge\n",
    "\n",
    "\n",
    "class GCN(torch.nn.Module):\n",
    "    def __init__(self, dataset, num_layers, hidden):\n",
    "        super(GCN, self).__init__()\n",
    "        self.conv1 = GCNConv(dataset.num_features, hidden)\n",
    "        self.convs = torch.nn.ModuleList()\n",
    "        for i in range(num_layers - 1):\n",
    "            self.convs.append(GCNConv(hidden, hidden))\n",
    "        self.lin1 = Linear(hidden, hidden)\n",
    "        self.lin2 = Linear(hidden, dataset.num_classes)\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        self.conv1.reset_parameters()\n",
    "        for conv in self.convs:\n",
    "            conv.reset_parameters()\n",
    "        self.lin1.reset_parameters()\n",
    "        self.lin2.reset_parameters()\n",
    "\n",
    "    def forward(self, data):\n",
    "\n",
    "        x, edge_index, batch = data.x, data.edge_index, data.batch\n",
    "        x = F.relu(self.conv1(x, edge_index))\n",
    "        for conv in self.convs:\n",
    "            x = F.relu(conv(x, edge_index))\n",
    "        x = global_mean_pool(x, batch)\n",
    "        x = F.relu(self.lin1(x))\n",
    "        x = F.dropout(x, p=0.5, training=self.training)\n",
    "        x = self.lin2(x)\n",
    "        return F.log_softmax(x, dim=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = get_dataset('MUTAG')\n",
    "\n",
    "data = GraphList(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.split_by_rand_pct(0.3)\n",
    "def func(x):\n",
    "    return x.y.item()\n",
    "\n",
    "data = data.label_from_func(func)\n",
    "def fun(data_list):\n",
    "    a, b = zip(*data_list)\n",
    "    a = MyBatch.from_data_list(\n",
    "            a, [])\n",
    "    a.__class__ = MyBatch\n",
    "    return a, torch.tensor([w.data for w in b]).long()\n",
    "data = data.databunch(collate_fn=lambda data_list: fun(data_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.700809</td>\n",
       "      <td>0.693907</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.696551</td>\n",
       "      <td>0.691743</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.694740</td>\n",
       "      <td>0.690098</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.687743</td>\n",
       "      <td>0.688591</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.684635</td>\n",
       "      <td>0.687515</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.682204</td>\n",
       "      <td>0.686536</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.680928</td>\n",
       "      <td>0.685718</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.677629</td>\n",
       "      <td>0.685097</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.674427</td>\n",
       "      <td>0.684589</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.671973</td>\n",
       "      <td>0.684248</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = GCN(dataset, 1, 16)\n",
    "learner = GraphLearner(data, model)\n",
    "learner.fit(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAcyCAYAAAA6+jYCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZxcVZ3///fpfUt3Z+luICHgIxEkOqMwURn0q6gBEUhkQKMCI5GAiCwqI/NVBxV/ooOIig4JRGlkkQBhzzbwhYHgOBEkkFEkQU0EmyQk3Vl6q16qu+r+/ji1V/VedW519ev5eORRVfdW3TrV+dSn7j2r8TxPAAA3ivwuAABMJSRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJt8AZY641xnjGmLzskG2M2RQp3ya/y5Ir0b+/MebayOOTE7adnIXj3xE51usTPRZyj6SbwhhTZoy5zBjza2PMQWNM0Biz2xjzG2PMN40xtX6XMRdy+cU1xhydkGSW5eD4NxljDhljSobYvynh/T1jTCjyf7rOGHNStsszCp2Sno/86xzti1KTd4KdkWNtzVoJkTMZg3SqMsbUS3pK0j9ENvVJ+rOkSkkLJb1P0iOS/jjMMco8zwvmuKi+y7PP+XFJGzzPGxzheUHZxFQu6R2SzpR0mjHmfZ7n/S7TCyKJPORlceim53kvSToxi8f7rqTvZut4yC3OdJPdrHjCXSFppud57/A8b56keknnSGqV0i4RLzbGPGOM6ZP0xcj+dxhjHjbG7I+cLb9mjLnRGFMTfbNMl9aZqgMSnxc5C3/dGNNljFlvjDks4XllxpibjTHtkbP0n0oqG+lDR85uL4g8PCrx0ne4z2mMWZaw7+jIsZLOaiNntq8lvN0vh6pOMMZcFPk7pX22Ycr+LklHS3p0pOdKetPzvBM9zzte0lmRbSWSzo0cK3a2Hyn7a7KJui6y/9PGmOeMMYHIv6eNMe9LKc//Mcb8rzGmzxizNXV/5DkZqxeMMf9gjHk0EjP9xpi/GWO+HX1+wiG+nXhVkukqxRhTbIz5F2PMK5FjdUbK+5EhyrEs8jfvifwfLE851nXGmB3GmF5jryr+1xhz/Sj+5kjleR7/7ElMnaQBSZ6k30sqGuH5J0ee60nql9QmaZukKyUdJ6krsq87sj0Uefw/0WNL2hTZtinhuNdGj5uwLfq8oKRe2bPv6Hvfk/C8GxK2vyb7A9GderwMn+WRSPmjn+W5yL8TRvicyxL2HR051tEJ25ZJOkP27DK6bWfk2CtTPlvPcJ9tmLJfG3ldzTDPib7H6wnbzkh4n5si2+5I+DuHJP1J0l7ZH9x/SXj+DkktCc/9x8jrmxL+33sjf6eOhNddmyF2To5sOyny940e84+R/79Nkf+H5xJesyvy+JGUcid+vttSyrs/cj8k6WMZyhGUjZmOhOe9LfK8KyLbBmW/G3+SvQrc4ff3djL+870A+fJP0rsTAvA/ErbfmrDdk3RjZHtiwD4jqSKyvVjSnYon3KMi27+Q8PzFkW3RZLAp4f2ujT4vYVv0eSFJ74xseziybW/kcVXki+5F9hlJ1ZJeTT3eEJ8/7Ys7is+5LGHf0ZHtRydsWzbUtrF8thHK/b+S1o/wnOh7RH9Qtir+Azsg6b0pfwNP0iWRbdG/Y/TH6/uR7UWSnohsezKy7TuRx2FJx0e2XZRwzGsz/E1Pjmx7OvK4XdJxCe99fMLnSDrOUP93kuZFyuBJujmybZriP2gvZijHA5H3+/uEbV+IPO8/Io+bE96zUtJJfn9vJ+M/qhcy8xLu/1W2kWI4qzzP65Mkz/NCsglckjZ7nve3yP3VCc9fOM5yvex53u8j97dFbpsit/MlVUTuP+BZAUkbxvlemaR+zmwa7rNlFKnSeKdGV7Ug2aqW98omljbZv80HPc9L/f/tlfQLKfJLJS2QTbyS9PXIpX5I0qmRbdH62b+L3P7F87xoo9b9oyzbeyO3j3ietz363gnHGYt/kE2gUiTuPM/rkrQ+su1dxpjilNfcE/ms2xK2Rf/+62W/ExcaY940xjwr6XsaQyMg4mhIi/uT7OVTiaT3GWNMJOhvkHRDSp1aqn3jfM/oMRO/AHXDPL894f5IjUa5kPo5E/8m0c8wXPmHM57PdpbsGd3aUT7/b57nHT2K57V5nhceYt+rspfgiYaLjcmiXZI8zxs0JpqvbeL2PO8JY8wJkj4p+yN3vKQPSLrYGLPA87w3fCjvpMWZboTneZ2S7os8PEHS9caYERuhoi9PefxC5PYkY8xRkfvnJuzfErltjdweHWmsqJD0sTEUO9EO2Xo2STrHWFWSTh/l63sit1Um4VuXIvVztibcnxe5/adhji3Fzxiz4SxJv/U8r3XEZ45N6ud8RfHP8LRsHe6JnuedKFvF8u3IvmivlvmRBj7JJqrRiJ5tn2WMOSa60RjzzoTn9EZuR/obvqj4Z/hM5DjTZHtrSNL/juVKxRjz97I/RP/med6Zijc210h6z2iPA4ukm+wK2YCVpH+VdCDSSvu3YV6TyfWydYDVkl4xxrwi2xtCkjYrfsn/X5HbOZJekv3SvnU8Bfc8ryfhPc6RrRZ5XdJbRnmIVyO3DZJejbTSV47wmudlP6ck3WuM+bWkazI8r03Sgcj9640xzxtjrhhluTIyxsyU9H6Nvmph3CJ/2+9EHn5R0p5Iz4RWSdsV/0FdKSkg+73aHPl//49Rvs01so1Z9ZL+aIx52RizV9JPE54T/T+60hjzgjHm+0OUd6ek2yMPLzfG7JBtJHur7JVBpv+j4SyV9IYxpsUY86KklyPbQ7I/SBgDkm4Cz/PaZfvifkXx1uLjZC+znpV0taSfjOI42yX9o2yvgH5Jx0h6Q9KPJH004dL1l5J+JtuyPFf2LOqnaQccvX+TdItsXdt02YQ02uPdLukh2UvnY2TrGFPr/ZJ4nndQ9kzqT7I/MMWSzsvwPE/SxbJn45WyZ0dHpT5vjBZH3i/nSVeSItVM58nGRa3s36hdttH0tshz9sr2ivhDpGxh2T7Eozn+ZtkeDI/J/v8dKxs7mxKedqXiCW9hpAxDuUQ2XrdJOlK2b/Izkk71PO8/R1OmBM9K2ij7PXiHbBXcZknneJ736nAvRDpjvw/A5GKMeVTSfM/z3uF3WYCxoCENk9VmRc4wgcmEM10AcIg6XQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIullgjLncGLPFGNNvjLnD7/IA2UBc50aJ3wUoEHskXSfpo5IqfS4LkC3EdQ6QdLPA87yHJckYs1DSHJ+LA2QFcZ0bVC8AgEMkXQBwiKQLAA6RdAHAIRrSssAYUyL7tyyWVGyMqZA06HneoL8lA8aPuM4NznSz4xpJvZK+Jun8yP1rfC0RMHHEdQ4Yz/P8LgMATBmc6QKAQyRdAHCIpAsADpF0AcChkbqM0cqGXDM+vS+xjVzLGNuc6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwyNnKEQsXLnT1VnBsy5YtfhfBV8R24cpFbI80iTnj05FrzL2AQlXYcy94nhQI+F0KIPuI7cIy6RemXLcu8/bFi92WA8g2YrswTeqku23b0Pu2b5eOOy7za559VpozRwqFpAMHpOXLc1dGYDyI7cI1qasXtm61tzfdtCy2bckSW43y0kvpz1+3Ttq50walJBUXS42NUnNzjgsKjBGxXbgmddKtrU1+fPHF81RZWatQKKTaWqmrK/01zz33qG66aZkOHNgtz/PU3t6qxkYbsEC+ILYL16ROup2d0urV1+rpp+/U7bd/Te3te7V69UEVFxers1OaNi3+3P37e9XR0aHjjvuQPC+smTNn65/+qVT19Y2SpCef9OlDABkQ24VrUifdvj7p3HOv1dq1ni644Ht64IGAiouLY/sSVVZWqq6uTnV1dTKmSI88cqPuvPOAHnnkRh9KDgyP2C5cedNPt7lZmjnT1kXt2iV98IPSggWje11FRadqE67HWlszNyAM1RosSU1NB3TssSWqq6sbVRk7O6Xjjx9dGcNhadUqGjiGUPD9dIntKStjbPuedMNh6Ze/tJX+mYyme8yOHZ42bTIaHJROOUWaNy/z84YKzNRADoVCam9v18yZM2PbmpvHV8bh3vNzn5OKJvW1RlYUbNIltod+7RSRn4MjVq2K/4d7nqdvfevUEV8TDku33GL/0x99VHr2WaMLL5S+8IWhg1KyATRvnj3bkOwvc6Yzh+Li4qSg/N3vDqixUfrVr66Jbfu3f/vQqD+jFH9tT0+nJPuZV60a0yEwyRDbyMT3frrRLi6S9I1vnKxZs45M2h8ISNXV8cfhsLRhQ/x1XV3tamys14YN0hlnjPzrumDB6C6bEr300kzNnm3vd3R0SJJOPPETsfuvvx5MKmNi2Ts6yiRJfX39am9v17RpNfrudxfrm99cl/TZUXiIbWTie9INhWw9kiS99trvdcUVyR0LA4E29fYazZo1S1K8/mjlykv1xS/eoj/+8Uk9+uiPdOONz2nVKunSS7NfxpLIX2nNmu+pqKhE69bdpHvvbY/tP+ooyWS4kJg1S3r5ZXt/7dobVVVVra1bn9CZZ35Jkv3sKFzENjLxPem++Wb8l33Vqr+lVfY3NjbE7nd1dauqKqRAoES1tfYS6f3v/6Tuu+87kqTDD89NGU8+2Y4CWrvWVgOee+61SfszBWXq9tTXtrcfUnf39CyXFPmE2EYmvtfpXnKJrXuSNGzrqiQVFdVoxow6VSdc7/T392vv3r9Kip9VZNv8+fEyDgwMZOWYweB0XXKJtHfv3oz7meRk8iO2ie1MfO+9EJXarebkkzOPL7/lFqXVF7W3H1J9/XTt2pWbS7DEMpaUdGjGjDp1dkonnJC5jKlG061mcHBQJSUlWrdOCgalsrLk/QU8yUnB9l6IIraJ7aSNfifd9ettIPb2duryy2tVWjr886ONDZmMprFhotra2tTQ0DDyE8fhxRd7tGdPla66aqF+/OMtWrLEqKKiWmvWdKulRbrsspy8rd8KNukS23HEdpxv1Qu9vbZbjOdJs2dLRx1Vqccfl9asGf51RUU2AFO7xrgIylx79dUqSdL112+ObXvf+z4pSZo715ciYRyI7XTEdpxvDWm//KV0ZEIPmtLIaUBl5civLSqyl1qBgFRVlVypHw6HVTRJIzQ68KisrEye52ntWk+HDsXrxVK7GCE/EdvpiO043/4HE4Nyy5aN+uUvr449Xr9+dMeork5vXc11UFZUVOTs2NFuNkuWGH3840W68MKjdMcd/xrbX1WVs7dGFhHb6YjtOF/OdBOnpQuHw/rLX7Zo9+4/x7bt3p2d99m9e7dmz56tbdvs/KS1tXZceV/f2MeHxxtDpo1p/PxYHDhgR/NEu+AkCgaH7r6D/EFsZ0Zsx/lypps4LV1RUZFefvlpeV78rx4dITNRs2fP1n33BbRzZ/zyprZ27JM7R8emR7vtzJlj5ygdbpKR8Vi+PN59J6qjo0OtrdLpp2f3vZAbxHZmxHacb9ULLS3x+9///iZ985uPanBwUJJ05pnZe5/q6mpt3vywJOmxx27Syy9vkqRRT+68Y0f6ZCA7d2aYuj9Lli+XTjtN2rfPnhX94z/Wafny0dUHIj8Q25kR25avXcZWrEhuuQwG7a9etv4TAgHp6afjj0OhkF5+eZPe/vYPKBwOa9cuTxdeGFQoFFI4HFY4HE47xp13Vuiww+Lb6+rq9Mwzd+tDH/pnSdKHP5z7BoD+/n6Vl5fn9k38U5Bdxojt0ZmKse3rMODLLov3ZSwpkS64QGpr26PKyiNy8n7FxcUqLi6OtSZXVEi1tcM3HtTUSHV1UjBoZ46++OJ5+sUv3K5/0tnZmbP+k8gNYnt0pmJs+z44IpNs/vpF66a6uro0LbHCTbaxYLjp8iR7CbZ9e/r2zk47ubSr0TQHDhzQzJkz1dWVXG9YAAryTHcoxHa6qRbbvk94k0l5ebkOHmzX/ffXZ21G+tSgbG0d3fDD+fPtstapdV/R2fw9z5PJcdNrb690330zky5XC3gUT0EjtpNNxdjOyzPdbM9In91uNenj5998800dnqtpoBT/e4RCodg6WVLBBOeUOtMltpNNxdieFEl36dIarVnTLUnjmvgjevmSS7k6K1i/3g4nleKBedFFR+u2216XZPs3ZrNFPJMcX/ZN6aRLbNv7Uym28656IXXKt+7ubv3sZy/HHo9nRvpcB6WkWFAeOnRI06fH5xLdsUPatEkaHJQWLbKXdGOxe7d0RKTtJRAI6OGHr0/bP1aZhpim6u2Vbr9daZd9F1449br4ZAuxnWyqxnbeD+SuqalRXV3TuF/f39+fxdKMbPr06Wpra5Nkz2q2b5eammyn+O3bx9bp3PM89fR0anBwUMFgnyoqyvTxj1+pcDikzs5OdXZ2jmme1ej6W08/LT322PCd6FevTp+IZO5cux3ZQWxPzdieFNULibZt69T//b+1Qz8hRWpdkSvbttmVXDNdls2fnz5XaSgU0sGDBzVr1qyk1wwMSI8/nvk9gkFpyRKptNQG8f79+4fsfjOWusShWrWjRtMyPgZTunohEbEdV8ixnfdnuolaW6Wrr7ZBGV04L9W2bdI998RXU73jDvdBKdnGDWOMfvGLf4lt27BhhSTpt7/tV1tbm3p7e2P7iouL1dDQkBbIpaX2ciiT009XbI5WY0xaULa1tamzszP2uK8voHA4rH37XtdvfvOAvvrVEzOu3PrUU/H73/72aZKkZcvi41effHL4z46xI7aTFXJs52XSXbw487yiy5fHf7USlz+JBum6dUoai25XUx3bWPRsiZahMlJJFAqF9LGP2VaShoZyNTQ0xPaNZOlS+zcxRtqzx94uXjxy/VNDQ4Nqa2tjdYmlpRU6dOigmpqO1vve9wl5nv3bTZvWoVDCSoLRxQqXLDHavv03uvfe76inpyNtP8aO2E42FWM7L6sXxuvee7tVU1Mjya73VJowVX+WLxtGdM89NjiXLLG/7rNnH6vDD5+nb31rgzo7pfPOc1cWz4tPKdjb263Kyho98cQdevLJW3Xjjc8pFJLOOiv+/OEu+yQ7fn6kVRDGYEpVL4wXsZ3ZZIztgjln8TzFgvK117bJmCKtXLlcN9zwP5KkZ55xG5h9fTYw77rroOrrp6ftcynxqq6y0v6NPvrRZXr3u5dIsqvWJiottWdfqZ3mJbs9i0GJUSC2hzYZYzsvqxfGo6cnfv8tb1mgurrpSZM+RyZ5ciY6lV1qUEYvJfPBjBkz9OabIV1wQfo35dOftt15otVmnZ22kSRfyj6VENtjl8+xXVDVC8O1DLu+BJNsXdfrrxfrmWfsF+OUU9yXIdFwK7fu27dPTU1NQ/4NczgOn+qFUSC2hzeZYntKJF0/foFzubJqrmzbNvQ8rJm6AmUJSXcUiO2JyafYLpjqBcn+Ys2bF79sSGwZdm2yBaVkuwJJdpapzZsfkqTYxNgv5W5ua4wCsT0x+RTbBdOQFrVgQfbXdxqrYDCosrIyfwsxDtGuQKtWfV5f/vLdGffBP8T2+OVTbBfUme5I9u3b5+R9JmNQSvEVWy+//DaVlpZqYKBfg4PBpH3IT8T28PIptqdU0m1qatLubC3HWoAOHLC30a43paXlOv74U5P2IT8R28PLp9guqIa00RocHFRJFoaepM5l+q53eXr72yf3WtLR1WET5bjukIa0LCK2h5YvsT0lk64k9fb2qry8MqmbyZtvSpdcMrqJpFNbkw8ePKgZM2bkVV/F8dq5Mz4G3UFXIJJulhHbQ8uH2J6ySTcclh54oEdVVVVp+844Y/jgzDRT0W9+s0bvf/9SSf70m5zESLpZRmznjcLvMjYWq1ZJVVVV6uzs1K9/fZ9+9KPzk/YNJzpTUSAQUEdHhzzP06FDe2P7mYULfiK281vBdRkbreiyT7W1tdq7969J+2bNGlBbW3vSturq6rQzh+rqarW3t6qrq1ONjUfnsrjAqBHb+W3Knukmzv38gQ+cp4GB+BjtiopSNTQ0JP1LDMpFi+Kvra9vlGT03vcuiW075ZRclhwYHrGd36Zs0o3OZypJhx12lL72tQcz7sskdS2o2oTe1a2t1HnBX8R2fpvSDWkbNmTeN1JjQ1Rqt5oTTsjZGO5CRkNalhHbeYPeC6lSZyYaS7eaVPv379esWbOyX8jCR9LNAWI7L5B0hzKaZZtHMhlnXsoTJN0cIrZ9RdJFXiLpolDRTxcA/DZl++nmwoMP9mr//kqVlEgXXMBaYigcxHb2UL0gu/BfT49UXT2+1/f22pE8HR0dSctn9/baJaYxLKoXcojY9lVhrwY8Hr290saNUuIUoS0t0mWXje040WOUl5do377XdeWVf6f77+9SZaVd8pmzArhGbOevKV2nu3p1clBK0ty5wy8CmEn0GBUV1aqpadDg4EBs3xNPTLCQwDgQ2/lryibdHTvS59Ycj66u5McrV35eDz0UH3bJvNJwjdjOb1M26UZnU4oaGOjXpz41LfY4EBjdcaZNS3589dX3JD2ePXs8pQPGj9jOb1M26SZOrt/d3a7e3j6Fw+HYtgxTkQ6ppcXe9vX1pe0788zxlhAYH2I7v03Z3gsDA9Ljjydv6+zsVG1trYJB6Zxzxna8FSukurp4C28wKJ1+ulRZmaUCFy56L2QZsZ03GJGWas2a9MDxPE+nnGLGHVDZGHY5xZB0c4DYzguMSEu1dKmdri66BHNnp3TYYd0T+gWvriYo4T9iO39N6TPdoQwMDKh0lB0Qg0HprrukwUE7AXTqfKQYEWe6DhHbTlG9MBbNzdLMmXYW/s5O6fjj7aJ8ie6/P94okThiZ9Ei6rvGgKTrGLHtDNULo9XcLJWUHIwte1Jba5duTuxYHgzGg3Lz5of1859/MbZv40aHhQXGgNj2H0k3RbRj+YwZM/TDH35Gvb3daml5Je15d90Vv3/SSWcnXbKVldkx70A+IbbzA0k3xaZN8fvPP/+YKitrdOedX4tt8zwpHA6ro6NbHR0d6ujoUGdnZ9pxursdFBYYA2I7P0zpCW8yGRyM3w+H7YO5c98e22ZnbCrSscfWJP3if/nLdyQdJ3U0D+A3Yjs/0JCWYscOafv2ofcvXhy/P9TkIeOZzWkKoyHNEWLbORrSRmP+fNu/cTQWLbKNDokISuQrYjs/cKY7hNRuNcMtQT3RiaKnOM50HSO2naGfLvISSReFiuoFAPCbs94LCxcudPVWcGzLli1+F8FXxHbhykVsU70Av1G9gEJF9QIA+I2kCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcChkSa88WtcPJBrxDZ8wZkuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0s0CY8zlxpgtxph+Y8wdfpcHyAbiOjdK/C5Agdgj6TpJH5VU6XNZgGwhrnOApJsFnuc9LEnGmIWS5vhcHCAriOvcoHoBABwi6QKAQyRdAHCIpAsADtGQlgXGmBLZv2WxpGJjTIWkQc/zBv0tGTB+xHVucKabHddI6pX0NUnnR+5f42uJgIkjrnPAeJ7nd00McQMAACAASURBVBkAYMrgTBcAHCLpAoBDJF0AcIikCwAOkXQBwKGR+unStQG5Znx6X2IbuZYxtjnTBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOCQs+V6Fi5c6Oqt4NiWLVv8LoKviO3ClYvYHmnlCManI9eYewGFirkXAMBvrAbswLZt0tatUm2t1NkpHX+8tGCB36UCJo7YHjuqF8YoHJZWrZIOP1wqLpZ27ZIuuUQqGuKaoblZamzMvG/x4tyVMxscfaGoXsgTxHbW34bqhYkKh6UNG6Q5c2xQSvb+hg12X6odO2xQbt78sG66aZn27Xs9af/Onbkv83g1N9vy1dbax7W19nFzs7/lQm4Q2+5im6Q7BqtW2duVKy+NbVu27IikfYmeesrennTS2ZKk2tpZOnRoX2z/k0/mppwTFf1CJdqyZaMkuz2fv1AYH2LbXWyTdMdgzhx7W1s7U5J0ySVvVXFxmTo6OjRtWofa2toUDAZjzy+J1JiHQoMKh0NqaXlF3d3dafvzTfQLJUnf+c7pam7+Fy1ceHpsW75+oTB+xLblIrbz9E+T/wKBgLq7DykQOKS6ujpJUkND8nNOPlnavl0qLi7RVVfdHdt+6NAhTZ8+XR/6kMMCj8PKlV/QV75yn6QBHTq0VxUVNaqsrPG7WMgxYju3aEgbg1tusWcE/f39Ki8vT9q3a5d06aXprxmusWHhwjd1+OGH56CkE7Njh/1CtbcfUn399LT9CxZI8+Zl7e1oSMsDxLblIrZJumMQDktr14ZUHG1pSHDGGUO38qa2lJ5wgnTccfH9nufJGBN77rPP2i9AKCQdOCAtX56LTzN0a7Uxnm6/3WT8QrW2Zr08JN08QGy7i22S7hh4nifPM2PqVjNara2tev75zKcNra3S5z438fdIFG2tTtXd3a1PfapGRUUjf6GyhKSbB4htd7FN0s0j69bFL++WLz9KN9ywWTNnzpY09CXeeN1yizRrVkBlZZX6zGfqdMUVt+u3v31UV199T9bfawQk3SmA2I6j90KCbduke+6xAXLPPfaxK4GAvY3Wp9XWNugHP1ga2x9tXc6WOXOkiopqhcMhfeAD5+rd716irVv/M+N7dXVl973hHrGdP7FN74WI+++XqqrSO0y/+GK//vmfy4d/cQ4sXnylPK9Ig4ODKhlD/5tAwH4OM8rzx3/7tw/r3//9Wf31r3/U6tUHk/YxxLMwENv5FdtUL0gKBqUnnpCuumqhfvzjLbrqqoWqqqrXddfZTn2nnSaVlua+HOvW2bo1SbHGh6hdu6RPfKJNDal9dxJem0mm4Zitra166KHGjGcY7e2H1N09XWVlmVumaUibXIjtuHyJbaoXJN11l7398Y/t3Jk/+MFv9fLLT8f233mnu7IYY9KCsrXVNmgkBmVra2ssiBMvFc85p0KXXnps7PH27bbfZVfCdVRjY6MuuSTz+9fXT9dHPiKVlR1SX19A4XBY+/a9Ls/zdMUVf8+ItEmG2I7Ll9gm6UoaHIzfb28/pJKSEj30UH/G/bm0eLHtI7hrl30cCsV/fVNbdxsbG2MBvHWr1N7eLkmqrJymL35xlQKBgPr7+/XSS1J1dbWmTZuW9PqiItsVaNcu+z6SvX/GGdLTT9sAraioViDQpaamo2WM0Wc/+++SGJE2mRDbdls+xTbVC7Idpp9/vlO10UqviO7ublVVVekd7yjKZodpeZ7U0yNVV2fneImXXx0dHfrJTz6ta6/9z9i2sc74dNttUlOTvd/b263KyhqFQiEtX36k7rhjj/btky66KAsFt6heyCFiO1k+xDYNaZLmzOnT9u21adtrauywwKambknJQwSDQXvpNjgoLVokzZ8/uvdqbpZmzrT9IKMV+LNnd8SGW45HKBSfGerii+fo619/OGnfWEWHeEqKDY0sLi7WHXfskaS8H+KJOGI7WT7Etq/VC8Gg/eVZtUpav979++/bZ2dFqqio0KJFUktL8v6WFht0NTU1CifMb9fcbBsnmpqk2bPtf+JopoWLDpuMBlFtrbR1a6d+/evxB6VkR/ZE/eIXu3T88adk3Dda8+fbS79MWluzOkyyYBHbxPZQfKteiHZjSbVokVRZObFjjzQZc1vb0C2lku27l1JNFHPTTV2aN8/u3LfvdV199Ym66669koZv/YyO+Y5aurRGq1a9oenT7fjviU76HA36cDisosgHnWhrLCPSxofYJrYj8qf3QjBog/Kqq+wqqps23aOlS2u0Y8eL2rgx82tG24l5uMmY9+yxATRcUEpDB6UkHX203dnd3a2tW5/QT37yYmzfzJm2TiuTxCnlJOlnP/tDLCileAfy8Vq+3PYzfPPNIu3bZ+9PtPvLggXSeefZL8155+UkKAsOsU1sj8SXM93Eyuyo1ta/qbHxKEnSmWfGO0CvWCHNnRt/XjAonX760GcM0dmSfvWra3T++ddJkrZvf07HHXdiVoYAJlbsL1litHZt8p/owx/O3IiQ+Jm3b9+sY455b9LkIomfeYopqDNdYpvYTpA/Z7qZuqlcdtkCdXR0SLKtn5K0cmVyUEpSWVn6L2uiaKdoz/PU0dGhUCikvXv/krRvIqJdXiTp/vsDafuGarW94IL4/eOOOykpKIPBKRuUBYfYJrZH4kvSjQbIkiVGS5bY/5Frrlkba+Xs6WlTf3+/jjwyvgaTJHV0tGnHDnvJk9qJub29XW1tbbHZ68PhsCory3XppcfoQx/656yV/YMfjN+vrEyuuDv55KFfV1qaXoEf7X9YVpalwsF3xLZFbA/Nl6R75pn2du1aL3YJ8853fkSSbVVtaGjQ4KAdE37SSWcrGAxqzZrva3BQ+vrXP6je3p60Tsz19fVqaGhQe7vtBnLBBf+usrIK3XBDvF4q8Zd8vKLjswOBgbR9I9ULLV9ugzPa1aWoqF7z5+f/yqkYPWLbPia2h+ZbP91Fi6SNG5N/CVtapMsus/ejrb+h0KBKSop19tlXyxijoiKjysqqIddguuSS5Lk06+vrk/Zlw+LF0sCAXQdqrB3BUxsAbJ16dq6/xjohCHKD2LaI7cx8H5HmeVJ3d+ZW1YceGvryZLiJOkbqVjNRra2tahxqnZJxiK4rNV6pE4IEg/bvNknOMgqqIS3pDYhtYjvTRr+T7nB6e6WHHkof0dLbKy1dOsSLMsh2IOWTbdvidYCp61vNnz8punkVbNIdDrE9skKN7bya8CY6iufWW+0oHmP6dP75dTJG2rPHXlqcdtrYglJS1oIylxMe79u3Tzt22M9+6622w/lobN0av//DH346ad9LL2WxgJgQYpvYjsqbM93e3vR6sNdeC+nKK9MXynMtcfTKG2906OST67I+4fFY5gyNCgTsrElRHR3pZ06T4DKs4M90ie3M26dqbOfNme5TTyUH5aFDh/SWtxRrxYrsHP/55w/o1lvt2cZof2klGzA7d8Zn3T/yyDrt3Jl5PHogML7RN9E5Qw8dOpS2L3F4ZaqqqnhrcX9/j8LhXnV0tMX2j2dCEGQfsU1sJ8qLWcaiE4JER9ocPHhQM2bMkJTegXw87NjtmZpt18HT9u12KeiRhhImBnAoNCjPk/bt+6tmzz4mNuHxvHmj+yWPNoAkLj8dXQU1eqaRqcHhpZeGrrsyxh6nsVEqKSnX9OmHJe0fz4QgyC5im9hOlRdnurt3Jz8+cOCv+stfXog9nkh9U3OztGOH7YQ+MBDUBRccLsn+Z440e1Li6CDP8xQIdOvnP78itu3JJ5Nntv/+9/9Jy5cfFXsc/SVPHDMv2Vbnxka7LRyOn2lI0oEDB/Sd75wee1ybPitfkmj/yFQ5WHoE40Bsx49BbFt5caY7e7btXrNmzfdUVFSiTZt+Jc8L6xe/+Kuk4SfpGMnMmVJj49n63e/WKhDoUVFRcdK+4ST2l/Q8qaKiTNdcsza2rbe3U88+K82ZY6PnG994JOn10V/y6FmAlDxuXpJuvLFLhx1WpenTbbk+//nZKi6Ov3Fn58ifcflyaefOYj35pC3zBRe4WfcKIyO2ie1UeZF0P/pR6fHHFRvBc+6518b2BYMTO3bCMPCkzuSp+zJJnPBYksrLk4dGLllSGzsb6O/vV29vb9IaUBUVFfK8ch1+ePJxOzs7VVRUpJqaGh1zzLSkS6WHHuqTJPX09Kiqqkp9fcOXUbKtw/PmNTHPbR4ituP7iG0rL6oXSkttC28mp5+eeftoRX9Nv/zlOyRJt9/+RmzRu5F+aaMz5nd0dKg05ec1OuFxtEK/vLxcK1Ys01e+8neqq6tTXV2dSkrK1dOT/AUIhUKqrq6KzdxfXJz5Mqqqqko7d3aO6jKqKXVaK+QNYpvYTpU3XcYkO/zwzjvtTE1z5sTHsU9EYgfrVKPtYD3chMfRCZYzidY9RafkyyRxSr6dO+ML451yig38N998U4ennk4kmOiInzxQ8F3GJGKb2E7YmE9JN1fG008wKnG2+qFkCs7Eyv5oY0MmZ5wx8hDO3bt3a3a0ebrwTImkmyvEdl6bukk3aqyTZniel1SPNZxMv+SJhutWMxrBYFBlZWVJiwaecMIBvec9I7SY5D+SbhYQ23mJpDuc5mapoiJ+mTVnTqs++MH8GtN+1119mj69Im17Ntbe8hFJN8eIbd/k94g0P/385+1qbIz3G7TB2ThkA4hfpk+vUE9Pj370o/P1+c+/Nbb99tt9LBTyGrGdf6Z80g0GpcMPr9eVV74rNov/Jz5hu89s3GgbQPJBdGRTVVWVrrjidu3dGx9SlI2RTSg8xHZ+mvJJ96677O3Pfva/8jxPt956hR58sEebNz+ksjLb4pwPEkc2lZWVpS0amMtZojA5Edv5acon3cSFBI0xamqyrQRz5749bb+fRmrgncjIJhQmYjs/TfmGtB07hp/taMGC9NZavwzVPShxKZhJiIa0HCG2fUdDWibz52eeVCMqX4JSsi25qUNHJ3lQIoeI7fw05c90pfRJpsPhsHbtKsrL//DEkU2Z+kxOQpzp5hCx7Sv66Y5GV5fU21u4607lIZKuI8S2cyRd5CWSLgoVdboA4DeS7hBah2uBACYxYttfVC8MYSwTgmBCqF5wjNh2huqFscj3oAxN5uVQ4Sti2195sVxPvlqzpkcHD1bl5dpMXV1daUu0AKNFbPuH6oUMenvtaqm9vT2qrKxK2r50qY8Fi9ixQ3r00S7V10/TySfHl16ZpKhecIjYdorqhdHauFHavPlhrVr1RQ0ODqql5RV9/esfVGWl/zMzNTfboZ2HHRZWU5O9P9Jy20AUse0/km4Kz7Ojd0466WxJUiAQUCgU0rZt/y3J35mZmpul6dP79alP2RlAli6t0dKlNWpsLMzgRHYR2/mBOt0U3d3Jj6urq1VaOl9lZXb6ej/r+CsqpNLSct1/f5eeeuou3Xtvu4qLS2L7gOEQ2/mBM90UidPIffnLdygQCKiqqkpr1tiITZ2Gbv16uz5UdCLmXIrO/v/DH35aCxYsUnFxiQ4d2pu0DxgKsZ0fSLoZtLSkb4t2s3nf+w5Jsg0P69bZS7YjjrC369ZJa9bkrlydnVJr69/0wgvr9ec/P6NPfrJad9zxr7F9wEiIbf/Re2EIK1YkLxUSDEqnn24XyQsGpTVrerVhww/01rcu1LHHnqiKihqVldnroNNOy00XnG3b7MqsUd3d3aqpqZFkW3mPOy777+kAvRccI7adYcKb8ci0tPVtt0lNTfb+1752so44Yp6uvLJZ//Vfd+gjH1mmffukiy7KTXnWrZM6OjpUV1cnSWpvP6T6+ulavDg37+cASdcnxHbOZYxtGtKGEQgEVF1dnbY9uszJypVf0PXXb1JHR5uCwT595CPLkvbnwuLFkufVqqcn+oWZnrs3Q8Eitv3DmW4GwaBd1K+9vUtve9s0nXlm8v71620911CMUdprcin6BerqmpTrSXGm6xCx7RTVC6Nx//32V1ZKvtRZtMjWeUWl1oslytXlUFeXVF0dVlFRcvtnallaWqQLL0wubx4j6TpCbDvHiLSRBIM2KFevvlYvvLBe5eVl2rbtN5LsSJ5El12W3hLc0mIDOJt6e6WHHrL1XZs2SatXd2nFivj+lSulRx9driuu+HtJ0nnnzdLcuXaoJxBFbOcPznQTJDYifPObi/Td7yb/7555ZnKjQ1QuL32GWyX1qKPil4KHDu3T1q1PqLn5Kt1zz35J7i8Fx4kzXQeIbV9wpjuSxEaEaFAGg30KBvskST09mV+Xq6BM7ZS+efNDkqR77/2O5s6Vdu+22z3PU1VVrWbOnK177tmvtWt/Kim+HyC28we9FxLMmWN/Xb/4xVtj26L9EyUpQ2NvTu3aFR8lNDg4oAULPiJJ+sxnvh3ZZvd9/ONFqqio1po13frkJ6v1wAMBSVJxsdvyIn8R2/mDM90Ew12uZBrJk2slkZ/ElSu/oIGBftXX1+vmmz8f23/xxbaubu1aLzaUMxqUkp0nFZCI7XxCnW6K3l7bsFBWFt/W0mIbF1wbGJAefzzzvmBQOuec+PyoqfJlftRRoE7XEWLbObqMjYXn2Xou15ddqdasydw9JrWbz/r1tp5r9uxJ0cCQiKTrGLHtDEl3shoYkJ54YtIG3khIulPYVIxtki78RtJFoaLLGAD4zVmXsYULF7p6Kzi2ZcsWv4vgK2K7cOUitqlegN+oXkChonoBAPxG0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDg0EgT3vg1Lh7INWIbvuBMFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIulmgTHmcmPMFmNMvzHmDr/LA2QDcZ0bJX4XoEDskXSdpI9KqvS5LEC2ENc5QNLNAs/zHpYkY8xCSXN8Lg6QFcR1blC9AAAOkXQBwCGSLgA4RNIFAIdoSMsCY0yJ7N+yWFKxMaZC0qDneYP+lgwYP+I6NzjTzY5rJPVK+pqk8yP3r/G1RMDEEdc5YDzP87sMADBlcKYLAA6RdAHAIZIuADhE0gUAh0bqMkYrG3LN+PS+xDZyLWNsc6YLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA45Gy5noULF7p6Kzi2ZcsWv4vgK2K7cOUitkdaOYJJQXIsEJCqqiTj17Qv/mPCmwJFbGeObRam9Mm2bdKzz0pz5kihkHTggLR8ud+lAiaO2B4eZ7o+WLcu8/bW1uGDc/16afduafZs6cwzc1M2H3CmW0CI7SQZY5uk64PUwPQ8TyZyDbZggTRvXvL++++3l2mpFi2SKitzVEh3SLoFhNhOwny6+SAQSH68evW1saCUpCefTN4fDCYH5Wc+M12h0KAkaeNGaWAgVyUFxobYHh2SrmOpv+p79+5MelySUst+113Jj++4Y7d+9zt7OlFWJt15Z7ZLCIwPsT06JF3HjLG/8FGf+MTd2rRJ+t3vpE2bpHe/O/n5g4PR20G1tu5SeXmV7rnnm2n7Ab8R26ND0vVBWZm97e+X9u6VPK9bkg3YlhZpzZr4c2fM6FEoFFJJSYkaG+foM5+Zru9+979i++fMcVlyYHjE9shoSPPJ738v3XyzdNhhUjgs/eUvz+n004/UzJmz5XmeFi7cryOOaJA0dItwS4t02WUOC50bNKQVGGI7hoa0fPLCC9KSJdJ73iO99a17dPrpc/XIIz+RJBljtHFjQ+y5ixbZIExUIEGJAkRsD4/BET5JrK8qKqqUMQOqqKjMuL+yMh6EXV3StGmOCgmMA7E9PKoXfLJjh7R9u3Tw4EHNmDEjbX+mPo0FiuqFAkNsx1C9kE/mz5f279+fMShbW6dMUKIAEdvDI+k6EAxKt90m3XqrPQuQpN27d+tzn5uVsT7r3HPdlxEYD2J77KheyLHmZqmxMXnbn/50UF/9avJZwFSpz8qA6oVJitgeEdULriUG5Te+cbIk6cCBAzr22Blqbk5+7hQNSkxSxPb4kXRzaObM+P0LLviBHntshWZGNs6cKQ1/kQHkL2J7/Ei6OVRcbG/b29sVCLSruLgkaV9Pj08FAyaI2B4/+umOg+dJ3d0jXza98Ua7jjyyXvX19TrhhI/qhBPi+zo67GgdIJ8Q27lHQ9oY9PbaKeei48ulzKNn9u/fr1mzZmnbNmln8kRLCgQG9Pvfl2rOHGnu3KGPMYXQkJYHiO2coCFtop56Kh6Ue/b8RZINrhUrpH379sWeN2vWLEm2E7iUPPPSK6+UqqenMxaUiccA/EJsu0PSHaX16+P3e3o6VVZWqVAopIGBAc2dKzU1NWV83eLF0jnn2CVI+vvtePRFi2p19tk2wu+882uSlBSogEvEtlvU6Y7S7t3SEUfY+5/97OGqqpqmGTOO0E03vSRp5L6IxtgF+qLHKCoqUTAYVEvLK7HnTOH+jPARse1WXiTdHTvs5U1JiXTBBVJpqd8lSjd7tm1kCAaDevDBQNr+0QRU9BiSdNNNf9R5503XAw/Ej0VQFh5ie/THmCp8b0hbsSL58iMYlE4/Pf8WpRsYkB58sFs1NTVp+4JBe5k1mmM8/njmfaM9RgEq2IY0YntsxyhA+deQtnKl9Ic/3Kyzzy6XJF166dvU3v43PfWUnaVoJIFAdjthZxpHHlVaKhUXpwelZL9II2luljZskH7zG2n9+lBal5rRHAOTB7E9tmNMJb6e6UZnjf/Vr67R+edfJ0m6/PJ36Oab/6jOTum884Z/XVQwaFteFy8ef1kyjSNvbZVOOaVNc+fGJ10eGLAL5oVC9pLqzDOHP244LP3yl8nHHhjw9MwzRuGw9LGPjXyMAleQZ7rENrGtIWLbtzrdrq7kx319Ul9fh/bu/askqbY28+u2bUvfFu3qsn27dNxxYy9LYlC2tLyioqJizZ59rBobjV54oSHpErG0VLrootEfe9Wq+FpPmzc/rOeff0xf+cqdOvVUu22KB2VBIrbtNmI7M9+qF6IV6+vXS8ccc53+8Afpz3+u01VX9ai/X+rsjD93//79amtrUygU0tat8e2e5+lb3zo19vill8ZXlsRx5HPnvl27d78mY+yPVFnZxC7zEhfXO+mks9P2B9LbLTDJEdsWsZ2Zr3W6d9+dftlTUmIXtquri2+bNWuWGhoa1NNTrNpaG5AdHR361399v2prZylaRTLUGcRIouPIJenXv75PpaVFam9vj22byDjyUCh+v6+vV56XXOFVVTX+YyN/EdvE9lB8TbpLl0qvvvqwNm68VJLU0vIbSbYe64034s8LhUKRs4EOhUJ2cbu6ujp973v/pVdf/W3slzsxCMYi8czjAx/4tE444aOqr6+X53lqbz+k6urxHVeS3nzT3nZ1damiolJXXXV30n7jV40mcorYJraH4lvSDQSk8nLps589W01NM3XggFRT84+aN69DJ5zQk3TpUlxcrIaGBtXX1+nAgfj2srIK3Xbba7HHifvG4vjjM283xqizc3qkvAGFh5nFI9o6vGpV8gifc8/tUmurNI2OilMGsY3h+JZ0o5ceodCgqqpCOvXUQX34wwOaNq1cVVVVQ/6yL19uW15TtbbafeORaRx5VHSyjurqahUV2T9X4lh0Sbr/fumJJ6SmJjsqx/NsK/Rrr+1VXd20WJmjn2nXLumMMybWIo38RWwT28PxtcvYQw8lz2qUaKRA27lTevLJ7I/08TxbzzXay6433zygLVtsa8Xq1dfq05/+ltraWjRr1pEKhYqnaqfwsSjILmPENjREbPuadHt77RDJTNuXLs3lO2fPbbfZs4D29nbV19erv79P5eUVsf1nnknd1ggKMukS21A+jkirrLTLMe/aZR+HQvYsYLIEpRS/rIo2Tnz726cm7e/u9qFQ8B2xjaH4PvfCZLd+/fB9HanbGlFBnukWAmJ7wvLvTLcQZBp109fXJ8nOmg9MVsR2bpB0s2DRouTW4YqKCr36as9UXqYEBYLYzj6qF7JotIv6IQnVC5MAsT0u+dd7odAFAgGVllbr//0/Ozv/aGZumoJIupMQsT0q1Om6VlRUrXXr7FlCtGM5i/ShEBDb40fSzaGnnpJKS5NPqFgdFYWA2B4/km6ORMeoG2N0003LkvaxOiomM2J7Yki6ObJ7d/Lj1tZWLVs2O/Y4daJrYLIgticmL1YDnqyGW+k1ujrqkiW2Lr2p6S3q6elQKBRScXExrcDIa8R27tB7YRx6e6XVq9MnqU4cV9/X16cnn6xIf7GkV1/t0dVXM8NzBL0X8gixnVX0XsiW1MX4oiorpS1b7ID0iooK9fZmfv3ll1cpEAhoYGAgh6UExo7Yzj2S7jgceaS9/dWvrolt+8Qn7K/7n/4UX8p66VLptNPsTEx79tjbxYttAFdXV6u0tFQdHR1px9+xwy6VfdttdoVWwBViO/eo0x2j1EaC6LR35eWVktLXsiotHb7TeF1kway2tjbV1DTEpgOcHWmXePzxyTUdICYvYtsNznTHKLGRYM2a72njxpu0dGmNrrvuGUnJa1KNRUNDgzZs8PTcc48mdcPxPE+VlXYpbSCXiG03SLrDCIdtQDz6qF2i5JZb7LbXXhtUOBzW2rWezj33Wq1Z0623vOXvJUknnDC+9/I8qbzc6MQTz4qtAHvffd+NLUyYuJT2WAUCE1tqG4WH2PYPSXcY0UaFmphnxwAAIABJREFU6DLWc+bYbRdfXKL9+9P/dL290nHHje+9EieEDoVC8jxPDz54faxeLHEp7dEKh+2X6emnpccei3+xRiMYtJ3gUxcjRGEgtv2LbbqMDaG52Qblc889qhNPPEuSdMEFR+jOO/fE1rgazVpWwaBGNSmI53l64IFeVVZm7m7T2Smdd57U39+vzs5OzZo1K3amkEk4LG3YkHnfGWdIRcP83N5/f3xxxUSLFtmGkiyjy5hjxHb6dpexzZnuEKKXPNGgvPjieSotLYvt8zy7HMsXviBddFHmoIyupJo4Kci6dUrqbtMaWf7VGKO2tqH7N0Yv7crLy9XQ0JAWlG1tbdq/f3/s8apV9nblykslSS+++J964YUNSfsyCQZtUC5ffpS+9KV3SYq3Xm/cOHVbnAsJse1vbJN0hxC95AkG+xQM9umGG/5H4XAotq+nZ/jXR/+DExsPOjraJEmPPTagwcFBSVJjQqfIyy5Ln5E/GLS/wiNd2jU0NGjWrFmSbD3XnDlSb2+vyspq5HmefvCDT+oHP/ikJLtvKHfdZW+bm/+ma699Qr/4xZf04IM92rz5IZWVSXfeOXw5kP+IbX9jmy5jQ9i1y/4HlpVVaGBA+u//rtcnP/mG9uyxlzcjLWN91112JdUTTzxLzz33qNas+b4+/OGL9MYb23XkkccNWY8VnZE/ELCBPZ7VVquq7KKClZWVKi0tUTgc0vXX/0adnbYOLbrgoCRt2yY9+6z9rKGQvb90qfTTn35OX/jCSh155NslSXPn2tvI9wmTGLHtb2xTpzuEaL3Rf/+3VF5uJ22ujkTj3LnS+ecPXwd0661STU2HpLCam6/UlVfeLmOM3nxzh+bMeZs+/OGRg3siovV2mezY0aGvfKVO69al79uzR/rjH6VTT03fJ0kLFthLzyyiTtcxYjvza13FNtULQygqspdD0V/tysr4WPPDDpNuvz39NaFQSG1tbQoEApozx3YOr6ubrquuulslJaUqLi7RnDlvk5TboJSkz31u6H1f+lKd+vr6FAxKV121MHaJuHRpjY44Qqqvz/yr39KS9aCED4jt9Ne5jG2S7jDq66WTTpLe/W7pXe8q1nXXGb3nPXbf3Lm2gv/gwYOx5xcXF6uhoUHV1dXDjtRxsZJqUZFtyd21yz4Ohez9aOtueXmFysqkG254TgMDA7r99q9qzZpuPffcY3rnO22rdGqZWYywcBDbyWV2GdvU6Q4jOuzRGKmiQrr77nYdOrRX06cfJkmqqGgYdhq7RYtsq2hZWXyby//goiLp0ksz74s2lpSUlKi0tFQXXnijJOkd7/iAysuld77TjqXv6mIxwkJEbPsX29TpDuOee2xwRucNbWw8Wm9/+//RV75im0EXLx79sfIxeWWq94rKQf3WUKjT9QGx7aQYGWN7Sp/pBoO2JXZw0P5yz5+fvP/II9vU0dGgtWvTv59jvYzKt6AcTmvr2L50yD/Edmb5ENtT9kx3uJEpUq8qI823vb3pl1GS//9x2ZLarebAATsiySHOdLOM2LbyNbanbNId6vIj08z3AwO24/TgoHTKKYXZgj+RvpMTRNLNMmI7Wb7F9pRMuuvXp89MtGzZbDU3t6i4uFiLF8fXiJIyX54ha0i6WURs5xX66UYlrmb6ne+cro6ODhljVBzpuHjzzdL27XYSj9mz7f2pNucnJidiO/8VbENac7PtClNba2cxOv5422op2WALhz19/ONFqqioVl1dnQ4c2K0lS4w+//k+LVo0qHC4Um1tLfrLX17Qiy/+p770pdvV3Oy8TghIQ2xPbgVZvTDcMMH3vGefGhsbtX595qvadetsQ8L+/W2aNatBknTuuTO0evVBhULSWWflqtRTFtULY0BsTypTo3ohGLRBuW/f63rhhfXq7m5XKDILxv79nWpqapIxZsjVTKPjsn/yE7twU2vr37R6tR2ZM57JloFsIbYLQ8El3ej0bU1NR2vt2ptUU1Ovzk4bWLNm1cYaGaKrme7bZ+vBFiywZwH9/Xb/975n14VqbDwqduzxrhEFZAOxXRgKrk43OpnFV796om688Tlt3fqkjj32vQoG+1RWVqGenviEHKWldpLmRMcfb2fNz2S8a0QB2UBsF4aCq9PdscO2yA5lNB2/h+rnWCidxvMMdbqjRGxPOlNjGPD8+XYUylCNDaMRDcBAwN7meqo6YDSI7cJQcGe6Uandak44YfyrmSKnONMdI2J70piaI9LycQYkJCHpjhOxnff8rV5YuHChq7eCY1u2bPG7CL4itgtXLmK74M90kfc400WhmhqDIwAgn5F0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADg00oQ3fo2LB3KN2IYvONMFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIugDgEEkXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwiKQLAA6RdAHAIZIuADhE0gUAh0i6AOAQSRcAHCLpAoBDJF0AcIikCwAOkXQBwCGSLgA4RNIFAIdIullgjJlhjHnEGBMwxvzNGHOu32UCJsoYc7kxZosxpt8Yc4ff5SkUJX4XoECskBSU1CTpXZI2GGN+73neK/4WC5iQPZKuk/RRSZU+l6VgGM/z/C7DpGaMqZZ0SNI7PM/7c2Tb3ZJ2e573NV8LB2SBMeY6SXM8z1vmd1kKAdULE3eMpMFowo34vaS3+1QeAHmMpDtxNZI6U7Z1SJrmQ1kA5DmS7sR1S6pN2VYrqcuHsgDIcyTdifuzpBJjzFsTtr1TEo1oANKQdCfI87yApIcl/X/GmGpjzPskfVzS3f6WDJgYY0yJMaZCUrGkYmNMhTGGHk8TRNLNji/KdqlplXSvpEvpLoYCcI2kXklfk3R+5P41vpaoANBlDAAc4kwXABwi6QKAQyRdAHCIpAsADo3U/YNWNuSa8el9iW3kWsbY5kwXABwi6QKAQyRdAHCIpAsADpF0AcAhki4AOETSBQCHSLoA4BBJFwAcIukCgEMkXQBwyNnSGwsXLnT1VnBsy5YtfhfBV8R24cpFbI+0ckReTQoSCNjb6mp/y4GsYsIbEdsFKmNsT4pF5sJhadUqac4c+3jXLumSS6QiKkcwyRHbU0/en+mGw9KGDZn3nXEGwVkApuyZLrFd8Cbn1I6rVtnblSsvlSTt2/e61q37WdI+YDIitqemvE+60cuu2tqZkqSmpqNVXFyStA+YjIjtqSnv63RDIam4WAqFQgqFBvX66y+rpWVbbB8wWRHbU1Pe1+k2N0uNjenbDx48qMHBGVq+3H2ZkFVTtk6X2C54GWM775PucI0NH/hAl+rqprktELJtyiZdYrvgTc6GtKIi25K7a1d8265ddltd3TTt2bPHv8IBE0BsT015cabreVJPz/g7hvf396u0tFRFCX1sPE/q7pamTZKThR07pKeekkpKpJNPlubPn/gxg0HprrukwUFp0aLsHDMHCvpMl9gmttM2+pl0163LvH3x4vEdr62tTTU1Ddq4USori29vaZEuu2x8x3QhU91ea6smVKd3//1SVVX69kWLpMrK8R83Bwoy6RLbFrGdzrfqhW3bht63ffv4jtnQ0KBHHulKCkpJmjtXWrFifMfMtcSgXLq0RmedVSzJbmtuHv8xo0G5deuTCofDsX0bN06ktBgNYtsitjPzLelu3Wpvf/Wra2Lbdu58SZL00kvjO+b69dK0adOUePb+uc/ZDo9z547vmLk2c2b8/po13Vq69JsZ9433mN/+9qnq7j4Ye1xWZi9PkTvEtkVsZ/b/s3fv8XHWdb7AP0/mksl1mqZJL+kFbAUbXhyV7a496BF0i/SUtmArXRT2lFIOpbaiB28ouKKr7iK+XPTYSrUBWmyllXZrE8qtQpejFdcKK2ALmiKE9JKZ5jKTy0xmMvOcP36dy5OZSTKZZ37PZT7v16uvuTzJzNP2k29+87s9hs3Tra3VPo5EIvja15Zgx44uVFYqCASA6mol2ZelKON/Cu3sBJqaxNeGw2GUl5drjg8Omm9DEYcjdb+vrxfXXPN/EAgEks/5/RHN1yuK+DcZfZt+X1UdiMXEv1d9/WzU1GgTbqX+QCtitgVmOzvDim76xPBIJIzNmy/B7t09yWO1tcAEsqjhPP+3iUTCKCtLhTkSiSAUCqGy0qvnX0EXwSBQVjaA6upq7Np1FzZt2qY51tCQ/2sODaV+8B9++B0AQDgchsfjAWD+UFodsy0w29kZNpCWa2I4MPmO9mgUeOqp7MciEWD1anE/Fouhp6cHDZP5X9dJV1cXpk+fjuPHgZMns3/NggXAwoX5v3au1xweHkZXV7nZBl5sN5DGbDPb55lrIG39ehHA0QoZ2XS5gFAo+7Fly1L3HQ6HJpS9vb3o7u6e3JtC9CMl9kMdSywWw/DwMABg+vTpAIDm5txfP5lQJl5zyRLxw5iuq6scn/60BTq9LI7ZZrbHYvg83ZMngeefF/PtrroKmD+/8NeMRoEdO8RHuaYmYPny/L5/YGAAoVBo3NZCKIQJTeFJ/OYfz+CgGJnN96PnWAqdJyqB7Vq6Ccx2CrOd9qTRRdfszp07B7fbjdrRoyMY+2PkihVibqWRH/PGMjw8nDEY099vSJ+YbYuu2THbRWeu7gWrmDZtmiaUfr8fqqqivT0Vym98Yxl6e88mv6avrw8ATBtKAMlQhkJinmdrK3DkiLg167xP0hezbQwW3Tw1NDRAURQcPiweBwIBrF37XaxdOzP5NVOmTJlQP5gZHD4MeL1iGs+aNdUAzD3hnoqH2ZaDRXeSElN4vF4vvv3tlXj0Ub/meLZlimbT1iZuvV4vuru74XJ5ksfmzk0dp9LCbBcXi+4krV2buv/Tn74Jr3caADFaHInoO2BQLKdOpe7X19fj0Ud9ycvFjD5OpYPZLi4W3UnKNYWnrq5OM4XHzJqaUvdVVUVZWRlWrLgj63EqHcx2cbHoFmDNGjH3MnFplc5OMem7ogKajTjM6uqrU/cDgT7NsUhEe5xKC7NdPJwyVmTBYDDrlByz2Ls3+3Z4ErfJ45Qxi2K2x8V5upRdV1cXfv/76Th1anIT7gvEoktFY8Zss+hK5PP50JhrxrlBAoEAvF5DN0th0bUBZjsrFl0zCIVCqDDZ9vYGY9G1CWY7A1ekmUEilNFo1OAzEevwifTCbE+MYfvpljqXy4UzZ85g5kyx2if9QnuzZxev7yn9IoGrVrGxR/pjtsfG7gWDDQ8P48CB8qJfaC8UAnbvztzEJBQS04MMxO4Fm2K22b1gSooiQjk8PIzbb78If/zjczh16s8A9L3Q3qFD2lDed98NAETwJ3uRQKKxMNvZsegabOdOcVteXo5oNIJ4fAQ/+clnAOh3oT1V1e6Lum/ffXA6Uz1Lk71IINFYmO3sWHQNNjKSun/PPQfx1luv4J57DiafGxoq/D1Gv8ZHP7oW4XBqq6j0CwgS6YXZzo4DaQabPTv1G//CC/8b6usvgMuV2oBZj13xR79GXd0M3H33vycfB4OFvwfRaMx2dmzpGmz0SG76wGZHh37vM9ZrXXaZfu9DlMBsZ8fZCyYw0etRFaq1Vfs4Eklc1NDQSe2cvWBjzHaWJ1l0zSNxoT1gEFVFvNpetosEhsNheDye3N9UPCy6JYDZTmH3gokoiuijGtJjhGEMVVWZG1F7PB5ERl/XmkgnzHYKW7qkEY1G4XK5ZL4lW7okhVmyzaJLOaUvq1y7VlxRoAhYdEk6I7PNoksZhoZU/OpXmXkp0rJKFl2SxgzZZp+uSY2kzyyX7MknFaiqing8jrVrZ+KZZ7YDMO+ySrKWUs82i64JHT8O/PSnQ2htBXbtEo9lSSyrVBQFZWVlWLz4Ohw6tDV53IzLKsk6mG0WXdNpaQFOngSammoAALW14rGs38KjB5dvuum7mD8/NcPcjMsqyRqYbYFF10Ta28VuSS++eACKouCGG7x4+OEvAhDPnzxZ/HMYPYWyuroan/nM9uTjzs7inwPZD7OdwqJrIkeOiNvFi68DAHz4w5/CunX3J48//7yc80hfVqmMmvR45ZVyzoHshdlOYdE1kdHjC+3tL2l2TJI1/rBpkwhn+kT2SERsPL1woZxzIHthtlM4ZcxE2tuBEye0z/X29qKurg4A0NwMzJ8v73xGRkYwPOzMWFapM04ZKwHMdgpbuiayYAHg82mfq6urw9DQEHw+uaH0+XxwOp1Zl1US5YvZTmFL14SOHwdeflmM7gaDYnu6urqzmDFjhtGnVgxs6ZYQZptF19T6+4GamtRjVVUzOv/1JGlp5GgsuiWolLPNoksAxFzJxMX9gsEgamtr4fMB69cX/a1ZdKmozJZt9umSJpRdXW/h1lubAIjnuOyXrMyM2WbRtaBxPp3k+Vra5Y/Tp1+AK674VPIxl/2STKWQbV6Y0oIURUE4HIbb7cHDD4vwOBxiRc2GDUBZHr9KBwdVDAwEoSgKamtr8YUvLMb3vvdi8jiX/ZJMpZBttnQtyu324LHH+tHYmArP7NnAE08A8Xju7/P7/ejp6Uk+rq5W0N/vRW1tLQBoQglw2S/JZ/dss+ha1MMPAzU1Nejt7cWddy7KOJYQiUTg9/uTjxsaGjB16lTN119xRe734bJfks3u2WbRtahEf1RdXR3uuecZAMDw8DACgQDq60V/FgC43W40NDSM+VrNzZnPJS4pxWW/JJvds80+XYtK749K/HYvLy9HeXk5ALGNXT4XXV2xQtxmu5oqkUx2zzZbuhaV3h8VDAYzjk32Ktdc9ktGs3u2uTjCouJxMbAAAIFAAF6vN3nsmmvyG+U1GBdHkIbds22d0yeNsjIRQJ8PqK4WoezstFwoiTLYPdts6dqAqubfz2UibOlSTnbMNosuGY1Fl+yK3QtEREbjlDELiseBbdvEKp1AIID+fm/eSySJzKgUss3uBYtJH9kFtKO7Fh1oYPcCASidbFvvr1Hi0pdBfve7/4DOzleyHiOymlLJNlu6FnPgQO7dkWIx4Lrr5J6PDtjSJQClk222dC0mPZT33/9JHD/+m6zHiKymVLLNgTSL6ewUgwwA8MUv/jzjGJFVlUq22b1gMaMHG9LZabBBAmbbZEol29b7a5S4xBLJ9N/8dloiSaWrVLLNlq6FDQ6KW4sukUxgS5cy2Dnb0vp0Fy1aNP4XkSUdO3bM6FMwFLNtX8XINlu6ZDS2dMmu2KdLRGQ0Fl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIolYdImIJBpvwxuj1sUTFRuzTYZgS5eISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXR0oirJZUZRjiqIMK4ryiNHnQ6QH5ro4nEafgE2cBvAtAFcDqDD4XIj0wlwXAYuuDlRV3Q8AiqIsAjDb4NMh0gVzXRzsXiAikohFl4hIIhZdIiKJWHSJiCTiQJoOFEVxQvxbOgA4FEXxABhRVXXE2DMjmjzmujjY0tXHPQBCAO4CcNP5+/cYekZEhWOui0BRVdXocyAiKhls6RIRScSiS0QkEYsuEZFELLpERBKNN2WMo2xUbIpB78tsU7FlzTZbukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCSRtMv1LFq0SNZbkWTHjh0z+hQMxWzbVzGyPd6VI7gpCBUbN7whu8qabV6YcoIiEWDnTmBkBFiyBFiwwOgzItIHsy1XybZ08wnanj1AZWXm80uWABUVxTvHEsGWrs6YbdPg1o4Je/YATz8NTJ8ONDUBJ04ALS1AKJT5tZFIKpRHj+7HAw/cnDx26JCc8yWaKGbb/Equ6La0pIJ2//2fxPHjvwYANDZmD9rOnan7l1++SnPM7QZ4MWUyC2bbGkqu6NbXp+6/+urzaG7+EAAgHA4jFArA5/PD7xd/RkZGMDKS+vpYbAThsLbJMDQk46yJxsdsW0PJFV2HI3X/4osvx/HjvwEAeDweeL1eVFU1oKFB/HE6nViyJP17nbjrrj2IxWLJ56qqZJ050diYbWsoudkLwSBQWyvu3333/ozjo4O2YIHoF0uXGHzs6CjGGRJNDrNtDSXX0n3/+8Vtb29vxrFcQVuyRAw6JDidTnR0AJs2FeEEiSaJ2baGkpwyNjgYx1NPlcHt1j6/YsXY36eqop8r0WIYGhpCZbb5NpQPThnTEbNtKlmzXXJFNxaLwXG+82t00Cbj9OnTmDVrFtragFOnRL/a2rWAy6XTCdsfi65OmG3TKd2iOzgoptIoRfjxDoWAtrYwPB5PxvNr1uj/fjbEolsAZtvUSm8ZcGur9rHfH8AnP+nVdaXNoUNidDgcHoTbXYFPftKLPXv6UVEBRKPjtwoSrYimJmD5cv3Oi+yN2bYu2w6kjQ4lADQ0eLF7NxCP6/c+ib6zWAwoKyvDyEg0eezpp3N/XygEbNkiPgbOmiVut2zR77zIvphta7Nt0U1ILG1MTPxubAS2bdPntfv7U/erqqpw990fwc6d3QgEAohEIjh1Kvf3Hj4MzJ2rfW7uXIaTJo7ZtiZbFt3BQe3j/v5+eDwV6OvzAQBmz9bnfWpqtI+//e3nUVVVBa/XC7fbjaam1DFVVZOrgdraMl/r17/eC0CEM9txIoDZtgNbFt3ETJfdu+/Fc8/twG9/ux833dSAKVMaAYiPS3rp6ADiOT7TpfdjKYqSXA00upXQ3d2N3t6zycdjtSKotDHb1mfb2Qv79qX6pAKBALxeb/KYzwesX6/P+wSDQTz6aK3m41QkAixblntrvLa21GYigYAft902H3v2BJPHFaWkBh44eyFPzLZllNaUsfTBhvRg+nzAunVAmQ5t/Gg0Ctf5Idx85jJGo8BTT2mfCwaDqK2tRSQCrFxZUnMhWXTzxGxbRmkVXUCM5G7bBtTUBFBd7UV3t36tgELt3ZvZWhgZGcHSpc5S2zyaRXcSmG1LKL2im+D3+9HQ0KDb6w0MDKC6ulqX1+JcRhbdQjDbpsaim694HHj4YbFPqcMBdHYCt92mwuEoXp3w+XxobBSDIsVcbWQiLLoFYLZNjUU3H/E48MQT2Y9dc40+/Wa57NzZi7q6uuTjSEQMnIy3aYlFsegWgNk2NV4jLR+JSeYvvngAAPDLXz6AV189ojlWDFu3AnV1dZrNpBMj1aP3PiWaDGbbWCVRdAcG8m9MzZwpbhcvvg4A8KEP/aPmWLGuHzVnjriNRqP4p3/6mObYkSPFeU+yLmbbemy74U0oBDz0kFgFEwi48NpryGtz5rIyFYGAmF8oLnWS2iPP4Sh827xs0lcbeTwefOUrBzTH9VptRNbGbFubbVu6hw8Dr7zyIzzwwM1ob/89brqpIef6797eXvj9fkSjqQ09Tp1S4PV6k3MgPR4PLr30SgBi0KEY149K3zN6eHgIvb1nEQj4k8/pudqIrIvZtjZbFt3E+u7lyzcDABYs+Fv87GfiP9jrDWDXrj7N19fV1aGhoSE5GRwANmzIfN3EoGO2Y3pQlNSlU8rLKzFr1rvg9aYGSbq7i/O+ZB3MtvXZsuiOXt/t9Xrx5JMPJu8PDEwZ9zXKysRIrs+X+i186pSCv/1bX1FHd5ctE+85elaJnss7ybqYbeuz5ZSx9PXfPT09mDp1quZ4oeu/+/v7UTN6Gyad/ed/nsNLL02D02n7S6RwylgemG1LKZ15utnWfyfotf5bVVUoNp/ZLQmLbh6YbUspnXm6LpcY4e3p6ck4tmyZPr9ZGUoyArNtfbZs6QLAmTNnMHPmzKKu/x4cHMRjj1VpllJecQXQ3FzY63Z3d6O+vl6fkzQ/tnTzxGxbRul0L8jS0gK4XNpljQn5LmuMRICdO4GREWD69Ag+/nG3Tmdpeiy6JsRs66J0uhdy7Xavp/Z2cU2quro6qKqKL33pcoTDg+jsfD3v19qzR1zob/p0YNq0YTidbrS2io+RROmYbeuzXdFVVRVlxZz3cl76ssVIJIJLLvkwPJ4qvPHGi+fPY+KvlZg4/tWvXombbkp99HroIR1OlGyD2bYH2y0DljUIMDIibiORMPr7g3jyyR9DVVXcfPN9AMRSynC4W9MycblcmDJFO49y9IX6Lrzwvcn7o6+oSqWN2bYHW/XpJgYYZGhvFzsjxePxrK2PifZ7bdsGzJqlfa619YdYseIOAMCVV2ZemdVm2Kc7Acy2JdmvT1dVtRtpyAolAMyfr8LnQ8Ef99IvZZ2wbFlq5xKbh5JyYLbty5It3VAIOHQotRcnAPz1rzHccYdDyvv39qZGdVtatLvvX3klsHBhfq+XfqHBdPnsHGVhbOmmYbZtxT5Txkb/R0YiEbjdbin/kcVYrZPtB+3tt1Vs3lwSk9RZdNMw27Zij+6F9nZxm9j1HgBuu+0CAPp2zvf3Z3uuvyiDGRUVYvlmV5eY7K4owObNCgKBgO7vRebFbJcGy7V0H3xQ21e0YcMkBKErAAAgAElEQVS7EYtFsX37WwCAj360sP1At2zRBjwSEcsrc106ur+/dPumdMKW7nnMtu3Yo6XrPD/JLRIJIxjsw733Po14PIZQaACAdrPkfG3dmtmiKCsbweHD2udCIRHg1lYxp7G1NfsG0kT5YLZLg+VauoldlhJ9XQDQ19eLKVPqEIkAq1dP7nXTt8xbs6Yae/cOYHh4GOXl5QC0W+bJHhwIh8PweDzJxzZrgbClex6zXRrZtlxL1+UC+vtHkqEEgClT6tDd3Y1lyyb/uumbQ3/zm8/h7rv/HuFwGIFAALFYLHl89IRvANiyRWy3P3du9uPpIhFg+3bxUXK8r01IhDJbC6SUl1PaDbNdGtm2VNFVVRXxeByf+pQTS5emOuebm4Gbb66HooQn/dpNTaJVAQC//e0v4HK5k9eRcjgcyb629ABHo1GcO+eDw5H6TT16Z/906evQm5pE62Oi69C3bgWmTh3QPDd3LjI+HpI1Mdulk23LLQNOTNh2uYBbb9UeS28h5KO3txdXX12HgwfF/MR16+7P+Jqrrxa3jrTpki6XC3V1UzEwIK5RFQqFMDQURTAI1NbWZrxGok9uzZpqRCIhHDggrpXy0ENjf3Rrb09cvroaqqrijTd+h4aGOaivFz8tJ08C8+fn93cm82G2SyPblmnpTmQOYVlZGc6cOZP8mLNt29gfc7q6ugCI3ZRcLuT8CBcKpTaHXrtWe8zhcOILX9h9/n4FNm+uzQhlb2+v5oKBe/cOYM2aryUfjzcdKP03fk/PGTQ2zsOhQ1uTzz377NjfT+bGbAulkm1TtXSPHwdefhmorRUXzOvuTl2wbqJzCF94YSYcjmFMny4GCRIfc5YsEVNjIpEIAoEAGhoaMH36dM33VlSIdeXpm0NffbV2N/7Ezv3Zptnk2rm/rq4OAwPi75XwqU/dq/masQYQnGn/S/X1s9DX58Pw8HDW42ROzHb2v1MpZts0sxdyjZrmc6XQSET0K7344gEsXnwdurrewvTpFwAA/P4AbrnFq8/JnpfPzv3pI8jZjLWJSDQKHDyoXdWT0NfXixtuqLPyxf1sP3uB2c59rBSzbaruhaNH9+OBB27Gq68eQUfHn/CVr1yBxkbRrzMRO3eK28WLr4OqqqitnYa3334DANDQ4M1rH9CJWL4c2LBhYpdKGetrOjrG/t6xPh6Wl4tQnj17dvyTIMMw29mVYrZNUXQTgbn88lUAgN//vg319RfgT396AQDw/PMTe51YLHVffGQrw7x5F2NwUCw5HBjI/n2y5BrJveWW8b+3okIMKASD4nEwCCxYAKxZIx7PmDEDPp9PnxMl3TDb439vqWXbFD0mQ0Pax7fc8j0AQHm5GBJNbKo8nsRUFQDo6+tLbqpcVSU+ehk96XrNGvFxascO8XeaPTu/Cwo2N499YcDGxkYAomUwY8aMjOPt7WLgwukUgyYW/thmGcz2xJRStk3fpwuI/4yJThsp8a3kNHw+HxobGxEKZZ/zGAqlWhMGKtk+XYDZniwrZ9sU3Qvp+vr6NI99vvzm6S1ZAgwPa3+eSjGUQKp1sGtXL6LRYaxfPw9/+MOT+OMff4W77/4IKipE6ySX48eBXbvED/uuXeIxTR6zrR8rZ9s0LV1g7Gk1E5XYhFlVRT+X0R+7jKaqqfmcfX29WL9+Jv7+79fh05/+MQCx8mn0RHxAbGB9Ptca+Yy4T5DtW7oAs10MVs22Kfp0Ey66aATNzYWdUmLXe0VhKAFtn+KOHXdi374wvvSlD6KvrxuK4kRvbxmGh93JzU+A1CW4s0mMuNttlVCxMdv6s2q2TdW90NPTU9D3l/LGyLkk9l/1+d7GCy/8HGvWVGPFis/ju99dDa/Xi4ULazSh9Pv9aG0NIhQSif7a15YAAP7611eSXzPREXdKYbb1Z9Vsm6ql25jrV9AY0le7eL36ThC3i44OYO7cedi3L7VpyuWXXwsgc4S5oaEBFRViGs/Wrbfjn//5MLq7T+HCC/9b8msmOuJOKcx2cVgx24b26ab3c0WjcfT2lk24T2X0LvhdXb248ca6nLvgl7p8rhqQuAR3LvmMuE+ALft0mW15rJZtw4ru6OkvAwMDqK6unlBn9tatiZ2JhPQrmI615JDEZb0rK0W/YOLffPTzgPGDDRIw2zZjlWybok/3jTd+h+rqarz++m8ntDQyEcoHHrgZnZ2vJ0MJTHzz5FJVVZUKX3V1Ne67bwCtrcBzz4l/u337xBzH9euzrxLSOZS2x2zLY5VsG1J0Bwe1j7u7zyIej8PtFp8HxtrObfSVTH/3O9Gs+Od/Fs2AsTZaJq2tW4F3v9uFdevm4A9/eBL/+q+fwBtvHElONm9uBm68UbSwbrwRWLjQ2PO1AmbbHMycbUNbupFIGJFIGLW1U6AoCgKB8ddXn//EgFhsBOFwCNde+znEYiN47bUjALQbMdPY5swBXK5yPPzwO3jkkS/jrrseTx6b6EYslB2zbSwzZ9s0fbpAajPn8Tqz9+0DFCUKV5YF1kuXmnvdtVkMDoqPXQAQj8cxONiPmhovXn31CC699EqcOgXcfruUU7F9ny7AbMtk9mybasqYoijo6lKxYkXqXLNtgLxsGXD4cGb60nfBp7ElLq/i872NjRsvhsPhRG3tNPh8b+PgQdWWm0cbidmWx+zZNs2UsfSlkUNDKh5+WNFMA+noAFatOoOZM2cmnxtrF3wa37592TePBqS2qmzX0gWYbaOZOdum2nshobUVuOOO9+GHP/wvrFlTjXg8jt27+3D2rLskN/coFpPs0GTLopsLsy2HmbNtiilj6drbxe0Pf/hfUFUVe/cOYP78v4Hb7cbcucZ3gttJYvPozk7xOBYTcxVNsCWeLTHb8pg526bruTt8WHykAkQ/WDQaxVVXpbaff/ZZbraip/E2jyb9MNtymTXbpmvpJjq5V65UsHKlAlWNYcmSdRnHiayG2SbAhH260Sjw1FPZj0UiwMqVHFSwmZLp02W2S441+nRdrtwXuVu2jKEk62K2CTBhSzdd+rSZfC5yR5ZSMi3ddMx2SbDOlDEqKSVZdKkkGLsibdGiRbLeiiQ7duyY0adgKGbbvoqRbbZ0yWhs6ZJdWWMgjYjIzlh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpJovA1vjFoXT1RszDYZgi1dIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHSJiCRi0SUikohFl4hIIhZdIiKJWHR1oCjKZkVRjimKMqwoyiNGnw+RHpjr4nAafQI2cRrAtwBcDaDC4HMh0gtzXQQsujpQVXU/ACiKsgjAbINPh0gXzHVxsHuBiEgiFl0iIolYdImIJGLRJSKSiANpOlAUxQnxb+kA4FAUxQNgRFXVEWPPjGjymOviYEtXH/cACAG4C8BN5+/fY+gZERWOuS4CRVVVo8+BiKhksKVLRCQRiy4RkUQsukREErHoEhFJNN6UMY6yUbEpBr0vs03FljXbbOkSEUnEoktEJBGLLhGRRCy6REQSsegSEUnEoktEJBGLLhGRRCy6REQSsegSEUnEoktEJJG0K0csWrRI1luRZMeOHTP6FAzFbNtXMbI93ibmXJ9Oxca9F8iuuPcCZervB3jxELIjs2abF6YsUVu2AHPnph5HIsCyZUBFhXHnRKQHs2ebLd0StHUr8MorP8IDD9yMaDSCW2+9AG43cPiw0WdGVBgrZJtFtwTNmQMsX74ZAOByubF9+1vJY21tBp0UkQ6skG0W3RLT3699PDw8rHl86pTEkyHSkVWyzdkLJai1NfcxRQGWL5d3LuDsBdKRFbLNlm4JikTE7cDAQMaxq6+WfDJEOrJCtll0S9CyZeK2urpa83woBLhcBpwQkU6skG12L5SwtjbRz+VwAGvXGhZKdi+Q7sycbRbdEuXz+dDY2Gj0aQAsuqQzs2ebRZeMxqJLdsWBNBL8fr/Rp0BUFFbINotuCaqqqjL6FIiKwgrZZvdCiVBVYGAAqKmZ+PfE48C2bcDs2UAsBnR3A+vWAWX6/qpm9wIVxGrZZtG1uVAIOHQIcLvF476+PgSDU7Bp09jfN9Yk82uu0TWcLLo0KVbNNrsXbO7wYRHKd945gRtu8GLKlCmYO1fsxDSeo0f344EHbkYweA6RSDj5/LZtRTxhogmyarZZdG0sfYOPz3/+b/Hoo+fwne98HIB267vRBgfF7eWXrwIAPPLIl+F2e/CrXz0CQHwkIzKSlbPNomtjnZ2p+/fddxT/6381wu2uRiAQQCAQwFtv+eH3iz+DiTRmcdFFHwAAXHzx4mKfMtGEWDnb3MTcxpzn/3cHBwdx5MijiMWi+MIXHk0enzdPbAIyWvoA8Oc+90jy/uzZ7wGgDTyREaycbQ6k2Vg0Chw4EIbH48k4FokAq1fn/l6jBxskYLYtzMrZZveCTQUCAbhcgKpmhhJIbQySy4oVIoCJ3/yxGODz6R5KorxZPdts6dpMLBaDw+HQPBeNAjt2iHA1NUnfU3Q8bOnShNgl2yy6NtLV1YXp06cbfRr5YtGlcdkp2/ygaBMWDSXRuOyWbbZ0LUJVgaEh7egrkP0jl8WwpVviSi3bLLpF1tICeDxAbS0QDALvfz/Q3Dzx78810rpiBaCqKpRs82KshUXXopjtcbF7QbaWFqCxUYQSELcnT449ZSXd8eOp+z/84Xp89rPvAwD09PTgxAnYIZRkUcz25LHoFkl7uwhlul//em9er/Hyy6n7d9zRgnvvfRqqqmLq1Kl46SUdTpJoEpjtwnBFWpEcPiymsCQEAgGcPv1XBAIBAMBbb0Uy+rDSud1ulJd7EI+7UFZWhlgshsrK2mQLINHCIJKN2S4Mi26RqaqKd975C5qa5mPevIXwer0AgIaGzIGD0ZzO1GTtj3/cCY+nCnv3iktLx2LFPGui8THbk8OiWyRLlgB//GMEbrcbc+deBAD4wAdWJo9PZIP77m7xMS4YDOLgQTXjGJERmO3CsE+3CILBIBYsAPr63AW9zvr1wNmzcdSO+rzl84ljRLIx24XjlLE89PfnviRILBZDWVlZxqjr6Gk1l10GLFyY3/uePAk8/zwwMgJcdRUwf/4k/wLmxCljJsBsFwXn6U7Wli3ajZE7OoBbbgEqKkS/VjweL8ok7jNnzmDmzJm6v67JsOgaiNkuKhbdycg179DnAz7xiUBy8IAmjUXXIMx20XFxRL7a27WP77tvDQCgr68XjY3AuXPFC+WZM2eK9tpEzLZx2NIdw4MPpuYjvvnmf6G+/kLNb/9Tp4Dbbzfo5OyDLV0DMNtSZM02p4yNwZn2rzNv3qUZfVvOIv3rxeNxlHGncCoiZts4bOmOIRoFDh4Ul3nOZulSwOUq/H0GB4HKSnFNp+HhYZSXlxf+otbBlq4BmG0p2NLNl8slLv3xxBOZYQmFCg/l6IGMQGAIq1dXFvaiRBPAbBuntNv5E+DxqGhuLkcwKB4Hg8CCBcCaNYW9braR45oaD3bvBuLxwl6baCKYbWOwe2EM4XD2q43qIT2YL754AJdc8veoOT87vbMT2LixKG9rRuxeMACzLQW7F/JVrFAODmofL158nebx7NlFeVuiJGbbOOxeyCFWxK2OKtO6tvr6ehGJhBGJhNPeu2hvTcRsG4xFN4vTp08X9dpMigL09oomwZQpdXC7PXC7Uy0Pu++yRMZhto3HogvxkSjRtR2NRjFr1qyivVf3+dRdf30VfL7M46GQ/XdZInmYbfMp6YG0eBzYtk30M8ViwJkzwC23RFFersMExVES/87pOzWNfv/u7pIMJQfSioDZNgVueJMuHgeeeEL7XHd3N+rr63HNNald7cdz/Li43lNie7twWBuu7u5ueL1eOIu1xMf6WHR1xmybBje8SbdtW+r+M89sR29vL+rr6zOOjaW1VewHmn5F1MZGsc9o8Pzkx/r6eoaSpGK2za1ki2761JW/+7vrcPvtc7Mem4hwWAwc7NhxF4aHh9HYCPj9Nr+6HpkWs21uJVt0YzExpQUAKiurEU9bKjPetJZ4PI6zZ/sRCAQQCATwxht/QF9fHzo6/pRcUvnss0U7daIxMdvmZuhng0gE2LlTBKGpCVi+XM77qqqKt96KYP78OgCA2+3BL36RmtU93nafZWVlqKmpQWInvPe+98MIhwexdu2/FuuUyWKYbcrFsIG0PXu0E6kTliwRlwophq6uLkyfPh1A9sGGhIkONuTaeR8Ampttd72nYrHdQBqzTeeZZyAtEtGGMhQaSN4/dGjir9PfP/7XDA8PJ1fgJEIJiOBdc41YCw6IFkln58RDORafj6EsVcw2jceQlu727UBaRnDddQ4cOJDqbFq+XKxsyWWsi+kl+P1+NDQ06HjW2Y03rYbGZauWLrNNacwzTzf9UiEnThzFvHmXorKyBqqqIhgM4qMfBWbNyn6Npq1bgTlzxP1Pf3ohNm36CS655H8AAK64IoiampqMS0WTqdmq6DLblMY83QtLlqTuL1x4OSorxbZviqLA6/VmhDIajcLv92P//uFkKGOxGEZGopg//28wNDQEAHjhhVqGkgzFbNN4DCm6CxbkPtbRkfmcy+VCQ0MDfD4xZWVkZARdXZ347nd/jy9/+YOoPN+JlujDIjIKs03jMWye7pIlYtAhXUcHsGlT7u9JLH5xOp2oqZmKjRsvxP33/zbjOJGRmG0ai+F7L6gqMDAAnN9YfkyyLqZHUtmqT1fzBsx2qTNPn246RZlYKIHUxfSy/aLQ42J6RHpitikbw1u6+Tpz5gxmzpyJtjbg1Cm5q32oKGzb0s0Xs2075pkyNlk+nw+NjY1Gnwbpi0UXzLZNWb/oki2x6JJdmbNPd6LSd0oishNmu7SYciJKeztw5AgwMiKm31RWni7qtZ2IZGG2yXTdCy0tYof65AmoKvx+hWu+7atkuheY7ZJj/u6F9FB+4xvL0Nt7FoqiJC8TQmRVzDYlmKroejyp+x/4wLUIBPqyHiOyGmabEkxVdGvTLr20devtuOCC92Q9RmQ1zDYlmKronr/IKADg4EE15zEiq2G2KcFURff978997LLL5J0Hkd6YbUowVdFtbs59bOFCeedBpDdmmxJMN2Us+cYqMDQEVFUZdQYkSclMGUu+MbNdKrgMmEyp5IoulYys2Za2Im3RokWy3ookO3bsmNGnYChm276KkW22dMlobOmSXZl/RRoRkd2x6BIRScSiS0QkEYsuEZFELLpERBKx6BIRScSiS0QkEYsuEZFELLpERBKx6BIRScSiS0Qk0Xgb3hi1Lp6o2JhtMgRbukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKJLRCQRiy4RkUQsukREErHoEhFJxKKrA0VRNiuKckxRlGFFUR4x+nyI9MBcF4fT6BOwidMAvgXgagAVBp8LkV6Y6yJg0dWBqqr7AUBRlEUAZht8OkS6YK6Lg90LREQSsegSEUnEoktEJBGLLhGRRBxI04GiKE6If0sHAIeiKB4AI6qqjhh7ZkSTx1wXB1u6+rgHQAjAXQBuOn//HkPPiKhwzHURKKqqGn0OREQlgy1dIiKJWHSJiCRi0SUikohFl4hIovGmjHGUjYpNMeh9mW0qtqzZZkuXiEgiFl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIomkXTli0aJFst6KJDt27JjRp2AoZtu+ipHt8TYx5/p0KjbuvUB2lTXbpr1GWns7cPgw4HQCa9cCLpfRZ0SkD2a7tJmupRsKiUBme37NGtlnQxKUTEuX2S451thl7NAh4OjR/di6dSMA4Ne//gW+8IXFqKgAolGDT46oAMw2ASYruqoKuN3A5ZevQm1tPQDgQx+6HmVlDgDAjh2Z3xOPAz/+MXDgANDaKu7H4zLPmmh8zDYlmKroDg2J21hsBLFYDLHYCI4e3YdoNIKBgQGMjGi/Ph4HnngCmD0bcIjsYvZs8RzDSWbCbFOCoX26kQiwcycQiwFNTcDy5eI3end3N+rr6zO+vrkZmD8fCAaDGB4exuOPN2D2bHHs9tsvwsaND+K97/0oAKCzE9i4sZhnTzqxZZ8us00w2+yFUEj0cU2fLh6rKrBlCxAKhXDxxZmhBEQoAaC2thYAMHMmEAgEUFtbi56e08lQJo6pKqAY9SNNJYvZprEY1r1w+DBw111iUnk0GsHKlQqqqrpRUVGBjg7t10YiwJIlma/hcABerxeKomDv3gEMDAxojiU+0hHJxGzTWAxp6ba1idvvf1+s9nC53Jg6dRbq6+tRXw+sWCGODw4ClZW5f6N3diL5EQwAqqurAQDRaBRdXS5UVRXrb0CUHbNN4zGkpXvqlPbx8PAwlLT09feL26qqsT9CbdiQ/XmXy4VVq/wFniVR/phtGo8hA2ltbaJPKl04HIbH4wGQag1MRDwObNsm+rkcDtFC2LABKDv/6+TMmTOYOXNm8uvb24EjR4CREfGxbsGCAv8yVChbDaQx25Qma7YNm73Q2pr5XDgchs/nwaZN+r6XqqpQFAUtLUBjo/aYzwesX6/v+1FebFV0AWabksy1Ii0UynzO4/Hguut6AIgBhu3bgQcfFL/BC6EoCl57LZ4RSkAE9cSJwl6fKB2zTWMxrOiuWQMsXQp0dQGnT4v+rRUrgKamqfjhDwfw9NNiyk1TkwhOS0th7/fHP4q/aiAQwKc/vVBz7KWXCnttonTMNo3F0BVpLhdw662in2r5cvFcSwtw4YXVeOGFPQDE+vQf/OAWNDYWFs7z0x/h9XoxPDyEd955M+MYkV6YbcrFVMuAASCxWOfDH/4HhEJD+NCHrsfvfncgeWzsLujcgkFxGwoN4e67f4m77vq75LF33gnk/XqDg5M/FypNzDYBJtxPN7HOPBIJw+Eow223zcfWrW8mjw0NYcw5iv39QE1N5vPz5wfg93tRUVGJd73rfdi161zy2Ec+4k3ej8Vi6O7uRmO2TjKIlUVz56YeRyLAsmVARcXE/n6J5aEjI2IeZqIVRPbHbBNgwpZu4re22+2B2+3BT35yElOmTAEgfmvnCuXx48CuXWLKzK5d4nFCd3c3Fi/2wufL/D6fD1iY1g3mcDiSofT5fEif3dHaqg2lOE9g9+6J/d1CIfEaif68xPJQKg3MNgEm3MT8+HHg5MnsxxYsSIXI5/MlA5Rtuoz4GmDt2hE4nakG/cmTwPPPi9/GV12VWvM+nlAohP37o8m18UBqug6Q2rBkLNmmEgFARwd0n0pkIbabMpYLs11yzDVlLJfmZnEbiWQeS/+tnQjlG2/EUF0tFqI/8MDNAMT2eaHQEBobgbff1vagzJ8vBjhuv33ioQSAeLxCE8odO+5BMBhEIBDA0NAQnn127O9PLA8FgC996XLNsdEtDLInZpsAE/bpAqlVO6o6fj/X88870NRUef7r1eTWecPDPaioqMSzz+YXwFwqK7WPu7vfRm1tbbI1kFjemcupU8CsWeL+66//Fn19ffj61z+CH/zg5eT3Z+uvI3thtsl0Ld10ijJ2KAFxcT8A2L37Xjz//E6cOPEcbryxAVOmNGqO63Eu6S2UO+98FCNpO0+vXTv29zc1pe7v3x/BHXe8B/ff/1sAQF9f34RDyZFle2C2M5VKtk3Xp5uvaBR46qlsz0fhcrmwdKl+V1st9MKCE+n3OnfuHKZNmzbu9+Y7sjzaRFpakpRMn26+mO3x3zcbs2fb1C3diXC5kHXk1ul04uzZuK6Xt66oSOzuLx7HYkB7e2DCV3LNtjwUAG65JXU/Ecqurq7kc9kCnRhZnsylW1pagF/+EnjuOXHdrfTRcDIPZnti753OCtm2fEs34fhx4OWXxQqcYBC47DLt4IRZRKPiIoQTncs4ODiIZ5/1wHF+kuc//dPH8M1vPpM8nu+lW3KNhgPZd8BqbxctIKdTfMzU8wf9PLZ0x8FsT4xVsm2bomukrq4uTJ8+Hf39QHW1vpdRGRwUv7UBMbXH7XYnQ3r6NPDaa8All0xsK7/29rE3QEkPZigkWhsSdq5i0TUxZrsg9uxeyEdLS+py1qMnmRfi8ceno7VVTF5vawP27cv9cStf6SPLZWUqgkE/3nrrz2htHUZnp2j9THTjlPQ+u2g0iq9/fanm+OBg6v6hQ6lQrlpVnny+0H0CqDiY7dR9s2e7ZIpu4qNHYilmba2YTJ5rAGCitm4VcxGDic4wiD6pbIMSk5E+slxeXom6uhn4858vQk1NDACwZ88NuP32iwDkDs1f/3oO586d04x2r17txokTv9Z8XWUl4Pf74fP54Xannl+16ouar8tyMVsyELNtrWyXRNFtbxf/aS++eCD53Gc+c6kurz1njrh96GSn0h0AACAASURBVKE70Nn5OoaGUgFNnzReiGXLtAMqtbVAZWUlQqEYvve9XTh9+i8YHBxEMBiE05na4GTLFvGD99pr0/Db305DTQ0wPCyOHTyoYu/e1MUOIxHxQ9DQ0ICqqgbN+8dHjWgkfrjJeMy29bJdEkX3yBFxu3jxdeju7gYA/N//+2ry+GTnBqZ/ZAGAo0f348CB72PNGnERwc7Oib3OeJPPKyqAdeu0rxcIAB/+cBn6+/vx2GODqKqqQm1tLVwu8V+abS19ZWXuH5b03/7pU22i0Sgef/xfsHv3vcnn0ho+ZDBmW7BStk25Ik1vafO8UV9fj89+9n3o7T2La6/9P1i9+suTntOX6JNKLM1cteqLePzxfwWgoK+vD07nlJzfGwoBDz2kDc9Y69TLysRIrt/vRzDYcH6fVAX33XctBgZ6kj9oqlqD9naxobXXK3aYeuaZ7fjYx24FAKxeLQYoFi5MXXfryivF4/RR8scfF7cf+5gLBw9qf3Ivuyz/fysqDmbbetkuidkLuUY2ExcMzOdigaPt2wc4HLHkqGu69MnrPp8PDQ0NyaWVra1AW9uP0N5+DO9731XYunUDvvOd/4Db/TfJcI6MjKC3txcNDdqPRONtnPIf/5FaJRQOhxGPR7Fu3Szs2SOaHadOifX56Ub3/6mqiv/8TyAQUPCxj4nnIhHRaijk3ysLzl4oALNtvWyXRPfCggXZJ5knrtB69uzZSb2uqqpYtgxZQxkKaef9NTY2JkPZ1iaWR1511f8GAFx55Y340Y/+hBkzLobXG0h+THI6nRmhBFIbp2SzcKF2eajH44HT6dL0XYVCQfj92S/jHQ6Lz5U7d34FH/iACOUFF4g5l6tX6x5KKhCzbb1sl0T3AiDm37W0iNFJh2P0JPMZALIvU0zfmDl9vmDiaysqxH9WW5v4LetwjD/RWmwQkvp4pqoqNm1qxi9+MZg8Pp6xNk5ZuxY4eDDVl+V2e5KvDQCbN9dqzi/RfxcKDeHPf/4Dmpv/Ozo6/pQ8/pvfAJfqMzZDRcBsWyvbJVN0ARFOVQUGBrLvejRt2jQMDw+jvFzM3WttFcGcPl0cP3FC/Fm06Axmzpyp+d58dslPNB52774Xzz23A5/73CO4556DGccnItvGKS6XdvAgnc+X+4emoqIS733vhxEOD2Lt2n+d+EmQ4Zht62S7JPp0J+OFF84hEJiGO+9chO9//xhWrlTg8VTh5z8P4OKLHQUtw8y1kQkgfhBWrtRnSeLo5aPhcO4VN2PN6ZzIJtYFYJ+uZMx2ihHZLqmWbj7eeWcaamuBb37zSPK5D37wejgcDrz0UmFr310u0S8WjQY1m0cDYt6iXmvAm5vH7iObCJ+P/bh2w2wLRmWbLd0cso149vX5UFcnPo9deWVhGzP39vairq4u2V/W1GT8hfzyaT3oiC1dyZhtY7PNopvDrl3AqF/UScEgcOON+b1eegA/8hEx4ZsAsOhKx2xLw6Kbj2zzBROTstMvIjiePXsyL4cCiNHiyW7SbDMsupIx29KU7jzdyWhuzpz/6PV6My5rPZ7Roezp6QEgVuwQGYHZNhZbuuNI35j5qquAefO0l70eS1ubdu37P/5jIx59NJV2RTG+r8sE2NI1CLNddJy9MBkul7isdYoTZ8+exYwZM8b93vSrpAJAPB7DX/7ye7z73X+bPE5kFGbbGOxemIQZM2bgzJkz435dYo34ypUKVq5U8MlPfgPf/e4/ZBwnMgtmu/jYvVCgsa6z1NfXh//3/7LvxjTWrkslht0LJsVsF4yzF/SW7UJ4iessJZZc5rvNXQli0TUhZlsXLLp6Sky7CYWGUFGhHca94IIoLr1Uu/TGTBPFTYZF12SYbd1wypieXn5Z3O7b953kcytXin/jV17JXOu4fDmwYQNDSebHbBcXi+4k9PdrV/REo1Fs2PBuVFaKJ3Ot9iEyO2a7+DhlbBJqasRyydpaYO/eb6OszImentN47DFxgSVeQ4ysitkuPvbpTtJ4lxUpZKemEsM+XZNhtnXDPl09ZVtKCSDvpZREZsNsFxdbugU6eRJ49llxbabRlwqhCWFL16SY7YJxylgxdXd3o76+3ujTsCIWXZNjtieNRZdMiUWX7Ip9ukRERmPRJSKSiPN0dRKJANu2heB2V3A5JNkKs60v9unqIHHZksQlTxJ42ZIJYZ+uiTHbBWGfbjFEIiKU69fPw1/+8hsAwCc+ITYJOXTIyDMjKgyzXRwsugXauVPctrS8jX/5l1X46U8/i8cfH8LRo/vgdmsvaUJkJcx2cbDoFmhkRNz+4AfrsG9fGLNmvQcAMHfuJQCAoSGjzoyoMMx2cbBPt0Dt7cCJE+J+ot+rt7cXdXV1AIAVKww8OWtgn65JMdsFY59uMSxYkLqfGGhIhLKjw4gzItIHs10cLLo6WLIEGBiIaJ4bfdmS/n7JJ0WkA2Zbf+xeKNDgoBjhVdU4FKUMAwNiT1IAGBiI4emnHXC7U1/Pa0hlYPeCSTHbBePeC3pqbdU+jkSAZcu0cxdbW4F16+aitnYqNm58EN/61gr87Gd+hlOLRddkmG3dsOjqZetWYMaMYdx00zTs2dOPW26Zi4ceEp1ciU2e29pSU2q6u0+jvn6W5jU4CJHEomsizLauOJCmlzlzAJerHHv29OPo0X3JUALAkSPitrNT3MbjcfzoR7dCVVXcfHNT8usGByWeMNEEMdvFx70X8pQeqPvvvwF33rlLc3z2bHHrPP8ve/31lXA4nHjssW9iaCiQ/LpK7ZWtiQzHbMvB7oU8qar4eOXzvY3Nmy/Bpz+9Dd///k0AgIMHVcRiwHXXAdEo8NRT2V8jEgFWr5Z40ubG7gWTYLZ1lzXbbOnmSVFEsBob52Hv3gEAwJVX3pg83t0tbl0uIBTKvinIsmUyzpQoP8y2HGzpTkIoBOzeDTQ2Zj6/Zo32uWgUePpp4NQpcFu87NjSNRFmW1ecvaC3xIX7nE5g7Vrwwn2Tw6JrQsy2Llh0yZRYdMmujO3TXbRokay3IsmOHTtm9CkYitm2r2Jkmy1dMhpbumRXXBxBRGQ0Fl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIolYdImIJBpvwxuj1sUTFRuzTYZgS5eISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXSIiiVh0iYgkYtElIpKIRZeISCIWXR0oirJZUZRjiqIMK4ryiNHnQ6QH5ro4nEafgE2cBvAtAFcDqDD4XIj0wlwXAYuuDlRV3Q8AiqIsAjDb4NMh0gVzXRzsXiAikohFl4hIIhZdIiKJWHSJiCTiQJoOFEVxQvxbOgA4FEXxABhRVXXE2DMjmjzmujjY0tXHPQBCAO4CcNP5+/cYekZEhWOui0BRVdXocyAiKhls6RIRScSiS0QkEYsuEZFELLpERBKx6BIRSTTePF1ObaBiUwx6X2abii1rttnSJSKSiEWXiEgiFl0iIolYdImIJGLRJSKSiEWXiEgiFl0iIolYdImIJGLRJSKSiEWXiEgiaZfrWbRokay3IsmOHTtm9CkYitm2r2Jke7wrR9h+fXpbG3DqFNDUBFx9NeByGX1GJYd7LxQJs2047r0w2pYtgKoCs2aJ24MHgVDI6LMiKhyzbV4lW3S3bgXmztU+53YDhw8bcz5EemG2za1ki+6cOdrHW7ZsSN5va5N8MkQ6YrbNTdpAmpn096fux+NxdHf7UFnpTT536pQBJ0WkA2bb/Eqy6NbUiNve3l7U1dXhjjsWYuvW1wEAfX19aGqaMub3RyLAM8+kBimWLy/2GRNNDLNtfracvaCqwNAQUFWV/XhXVxcef3x6Rr9XwooV4tbn86GhoQGKkhqE3LMHqKzM/J4lS4CKigJPvDRx9kIemG1LyZpt2xXdlhagvh5wOIBgEHj/+4Hm5tTxWCwGh8OBUCj7wEIoBKxZo33O5/OhsbERANDamv19OzqATZt0+kuUFhbdCWK2Lcf+U8ZaWoDGRhFKAKitBU6eFGHqP9/Z5Th/sKJC/NZXFOD0aXG7dGlmKAEkQ9nWJj6iJfzqVzuS93O1LIj0wGzbh22Kbnu7CCUArFlTDQD42c++lgxSTaKza5Tly4ENG8TteJPHT50CpkxJ9Yk99dRPNMfTBzGI9MJs24ttim76x6n77juKr33tKvT0nE4GaXCw8PdoatI+vv/+32ge58g+UUGYbXuxTdF1ps3DOHLkUTgcTtxxR0vyuWwDBPkaayS3o6Pw1yfKhtm2F9sMpEWjwFNPZT8WiQCrV+vzPqEQcOiQWOGT8OqrAXz1q97c30Rj4UDaOJhty7L3QJrLBfh82Y+lh6hQFRXAypXaQQqGkoqJ2bYX27R0E0ZPq7nsMmDhwuK/bygUQgUnM04GW7oTxGxbTmnM0zXSuXPnMG3aNKNPw2pYdC2A2Z4UFl0Zurq60N8/HYcPiwGQtWu5j+k4WHQtgtnOG4tusYVCwO7dqTmVCT4fsH69MedkASy6FsBsT4q9B9ISIhFg+3bgwQflb2P38MMilIFAAABw/fVigXxjI3DihNxzIfthtu3BVkV3zx7g6aeB6dPFZG9VFcskZe2Yn9jH1Ov14uMfd6O6ui557KWX5JwD2ROzbR+2KbqRiJgk/uKLBwAAN9zgRSQSBiDmHhbb6GWSXm8jHnzwZPJxbW3xz4Hsidm2F9sU3Z07xe3ixdcBAP7n/9wIt9uDX/3qEbjdomVQTDU1QF9fLxJ95I880ony8nKEQkOIx+MIBov7/mRfzLa92KbojoyI20gkjJ6ec3jyyR8jEgnjAx/4BAKBAIaG8n/NtjbRf7Z9u1gVlIvv/Mz1YLBOsz8pAFRUVKKsrAwXXNCT/wkQgdm2G9vMXmhvFx36qqpmhANIbd48ODiIoaEhNDQ05HytiexHOnL+J8Hp1F58Y/SepJGIWDWUeP9wOAyPxzOxv1Rp4OyFcTDblmXv2QsLFojbaJZf2+kbdlRVVSVDOTw8DL/fn/H1Dz+c/T0qKkTw+/v74XQ6M0IJiAA2N4ut8rq6xLLKRCgBwOPxYGgyTRMqWcy2vdimpQsAb755Bi+/PFOzHj3fXe/9fj9+85upcDgceOCBm/G5zz0CQLQiqqqqoCj6XDeqv78fVVVVKCuzze+9yWJLdwKYbUvKmm3bXJiyp6cH73rXTLzrXeNfR2osHk9Dcnd+ABgYGEB1dTWqzr+YXldTTWw87ff7k62T48eBl18Wo8GxGNDdzYnnxGzbjS1+FZ0+fRpTp05NPlaUyYUSSG3WvHv3vXjuuR04ePB7WLlSwcqV4pfW6M2eC5UI5b59wzh5MjX9xuEQE89bWsb4ZrI9Ztt+LNe90N4OzdrvwcE+zWVG9LBlS+Z1oRKDGOl9WHpqbU19zHvhhcfw+9+34fOf/xkA0Y82f35x3tcE2L1wHrNtO9YeSAuFxH/eiRPiN/L06cCTT6p45hl9QwmIfrLRu+VHowqWLNH9rQCkLrdSVVWFN9/8LzQ3f1Rz/Nlni/O+ZA7MdmmxTNF9+GGgre1HWLWqHIC4QN/Pf/4NFGubz02bxEe59JHawcFzxXmzNE1NF8HhiGN4mKPApYLZLi2WGUibMweYM2cz+vrOAgA8nlosX74ZgJjorceo62ijX7NY+4mm99GVl1eivLwSX/3q/uRzV11VlLclk2C2S4slim62yz/v3HkaK1cqOHhQ1W3UdSJyTVDXS0cH8NprwLRpQDwuWiOF9rVFImIpaSwmPr4W44eYJofZLuw1rZhtywykjV4Nk06v+YUTdebMGcycOROA6LOqrBTnUKgtW4A33xSvF4+LH8irrhJ7lq5bB0xm2uOePdmvFrtkCYr28TVPJT+QxmyXVrYt06c7uvM/feWL7N9uM2fOxM6dvWhtBZ57TnwE3Lev8G325s4FrrwS+Lu/Ay666BwefXQGAKCuLopt2/J/vcTuVAAQjQ5j/fp5+MMfngQgZ3cqmhhmO//Xs3K2LVN0b7lF+zixJFLWfqLpWluBuro6zXNut9hZPx6f3GuO/sDx6KN3YerUWQAAl8uFmpqBvF/zmWdS912ucrS0vI1HHvly8nzJHJjt0sq2ZYpuRYV27Xc47MXSpalNOoywZcvtAIChoSC+/vWlaGzEhH9rR6NR+P3+5J+ODu3o8Wc/ux3z51+WfOz1VuPUGB18qqpieHgY/f39OHfuHPx+P15/vR+BQCD5p7e3F//2b39Ifk+2/sRsJvp1NDnMdmll2xIDaenmzzd2MnVi3iEAeL3T0NPTg6lTp+Laaz+PQCCAmhrA74+gvLwctWPs7uxyuTJ2g3rlFe3XfOYz25P3OzuBFSua0N3djfr6erS1iR9QhyNxgUAF5eXlKC8vTy7DfM97Uq0Mn+9tbNx4MRwOJ/buHcDAwADi8RgAb9bzC4WAhx7STqTv6BCtMpP0l9kOs10a2bZMSzebbLsuFVt6x30sFoPXW4t///fv4bLLroLX60V1tRcNDQ1jhjJfPh+wYUPi/euxf38UqgrMmiUm0j/1FLB3b+b3pfcHNjbOw759YezdKz7K9fRUw+tNhdLv9yOe9vnx8OFUKBPzR+fOzb4tIOmP2bZvti1ddPv6+jA4WPyd89MpiujEB4C1a/8FDocTH//4F5LHu7sn/9orVoiWTmeneByLpa62mhjdPXRItCRGq6jIvhn1kiWp803ItjtVQ0NDcleoAwdGkhcgBIBVq76o+VrZF0UsRcx2it2ybbnuhQQxzSZzs+ZirR9P98EPBvDEE96My1GHQoXvnNTcLP5ko6raQYJodBg33TQNe/aIjqkdO4Bbb9V+T0UFsHq1+N6BgdSmJwn9/UB1tXZaUFeXE7NmiZZCLBbD6GmFMueOliJm297ZtmRLd6xR1MmOsOZjxgwv1q3L/K1d7IGPgVGDvE6nG+9+92IMnD8Qi+X+XkXRhvL4cWDXLuDIEeCXv9Tu+JTY/q+vrxcOhwO/+MV3sHv3vRnHSX/MtmDnbFtmcUS6H/8YmD0b2Lp1IzZu3IqzZ9/EV77yP/DII6fR2Qls3Gj0GRbPeBPpr7lGxblz5+BwODRbAk7kNXw+4JZbVAwORvD88+U532fpUiDLp8DJKvnFEemY7ezslG1TtHTz7buaPVvc1tbWIxgMoqzMAafTrTlmV6Mn0qdbvhxQFAUNDQ2aUKqqCr/fj54e7QUEw2ExXP397/8jotEoGhpUvPmmgurq8pxzREMhXUNpe8z2xJVKtg3t0x29t2ckAixbNv60jZ6eAOrqahGLxVBdXYV4PIR4PIa+vj5UVFTDwl3V49q0Kfe/Wy6JsAKpaUGqquKNN/6AefMuxYUXvi85gPHss2LAI/FxMjF9xyrr2s2C2c5fqWTbsO6FrVvF7krZpA8YqKr4SJE+76+lBRkd/QmJEVFATBWprq5GRR6T76xUZLINFIxHVbUjtNdfX4XNm3+KK674FACx1d/oAYsis133ArNdODtn27Cim9730tn5OmbPfg8AcfnnoaEBfOpT3jF3PMoWzvRQZuPz+dCYI9HZNs8YGBiAw1Ft6MqgYti3L/dSSZ37tCbCdkWX2TaOFbJtSJ9u+soXADh6dD+6u/14++0/wel0or9/yrhbzI0eYe3sFM+NJRFKVVXh8/k0xyorgTvvXARA3H7ta0vOtyQm/veyilyh9PnYX1soZttYVsi2IS3dxMeASCQMACgrc0BRFJw5047Zs98j/WPAvn1hhELDmlUs115bhl/+UszRkb29ngwmujqrrVq6zLbxzJ5tQ3rlEytf3G6P5vnEx7C1a+Wez7lzHsyalTqX7u5u7N+fWupix8UAY01Up8ljto1n9mwbNmUs14ikEVOSRl96ur6+HoODQzmPE42F2aaxGL44oq1N9FklLjttVL9LtknV4XAYHo9HyvLLEmar7oV0zHbJM0/3Qjqz9CeFQplzKD0eD/r7R2CCfyayIGabsjG8pWs22eYyFvuCfSXOti1ds2G2pTPXPF2i81h0ya7MM0+XiKhUsegSEUnEopun2KiNPWXv7k9ULMy2HOzTnQS/34/6+gZs2ya22zN41YvVsU/XRJhtXXEgTS+trWLDkOrqas3zPp9YI1/Gzw/5YNE1EWZbVxxI01N1dTX+7d9uST6+7bb5aGwEtm0z8KSIdMBsFxeLbp7Sd5FqaJiF7vOXSP3JT04CsP/u/mRfzLYcLLp5St+XNBaLYcoUL370o9ugqir6+vrGvIBeuvZ2YPt24MEHxX0iozHbcrBPdxLG2ig5sdm03+/H1KlT4chyedHJbFJtY+zTNRFmW1fs09XL6FAmfnElBhsAoKGhAQ6HA4FAQLOp9PHj2S/H0tgInDhRrDMmmhhmu/hYdCdhxQrgmmtSu/v39gaTv81Hj+56vV7NZVSOHAkAAB544ObkczfdJK6R9dJLRT1tonEx28XHLYYmqawM2Lgx8cg71pdqzJmT+trh4WF0dLwKh0P8N9TW6niCRJPEbBcXi64OWlqA+nrA4QCCQeD978+9c30wCLS13YvnntuBxsYLcOTIz3DddV9IHiMyE2ZbfxxIK1Bi4CDbFnnZNog+fhw4eTL7ay1YACxcWISTNDcOpJkUs10wDqTpLRIRoVy1qhzBYBC33bYAX//60uSxbJqbxaDEaP+/vbuPjeu6zzz+XPFdpPgqiVIk20XFjSGlwa4UBTayWMBdy4lXlSynimVnbYRx5K3XUQQ0BlIEtutiXRfbuK3hJpVsB2Ls2M2L5ChWLEXr2GprB21jN1SCNI1UBBRiq3ojKYpvIocccnj3j6N5H1Kk5t5z5975fgBjXi45c2Q9+s2Zc885t6+vLEOJEkW2/cPwQhFeeklqb5d+//e/pIaGBn396z0aGDBX+quuNpuFFNofeudO0yP4h3+Qpqel224r3HMAgkK2/UPRLcL0dPp+cs7ixER6Wc/4uFRfX/h316wx/wGliGz7hzHdIvT0zD3/kE/4eWFMtwSRbU8wpuu1jo7CY1hA2JFt/9DT9UDutJoNGzhxsAD0dEsY2S4K++n6yXXnHufCrCi6JY5sX7OC2bZ2Im3jxo223gqWdXd3B92EQJHt6PIj2/R0ETR6uogqTqQBQNAougBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYBFFFwAsutqGN0Gtiwf8RrYRCHq6AGARRRcALKLoAoBFFF0AsIiiCwAWUXQBwCKKLgBYRNEFAIsougBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYBFFFwAsougCgEUUXQCwiKILABZRdAHAIoouAFhE0QUAiyi6AGARRRcALKLoAoBFFF0AsIiiCwAWUXQBwCKKLgBYRNEFAIsougBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYBFFFwAsougCgEUUXQCwiKILABZRdAHAIoouAFhE0QUAiyi6AGARRdcDjuN8wXGcbsdxJh3HeTHo9gBeINf+qAy6ARFxTtKTkj4hqS7gtgBeIdc+oOh6wHXd70uS4zgbJa0OuDmAJ8i1PxheAACLKLoAYBFFFwAsougCgEWcSPOA4ziVMv8vKyRVOI5TK2nadd3pYFsGXDty7Q96ut54TFJM0pcl3Xfl/mOBtggoHrn2geO6btBtAICyQU8XACyi6AKARRRdALCIogsAFlF0AcCiq83TZWoD/OYE9L5kG34rmG16ugBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYBFFFwAssna5no0bN9p6K1jW3d0ddBMCRbajy49sX+3KEaxPh9/YewFRxd4LABA0iu4cRkclLiGHKCLbweES7AXs2SNdf336cTwubd4s1dUF1ybAC2Q7ePR0c+zdmx1KSaqulo4dC6Y9gFfIdmmg6Oa47jpz+/77/yZJevzxj6eOHTkSRIsAb5Dt0kDRzTA6mr5/ww2/o09/ulVNTctTz509G0CjAA+Q7dJRNkU3Hpf27ZOee272T/WGBnM7NDQkSXrxxTM6efKflEgkJEkVFTZaCiwM2Q6Xspinu3+/tHhx/vObNqVPIPT19WnZsmX6/vcdVVfn/+zk5KS2batRVZW/bS1DzNMtAtkuaeU5TzceN6Hcu/chSdI//uMreuGFL0mSDh4cT33SL1++XI7jaPPmwq8zM2NC2dvbm3esp8f0MvbtM/cBG8h2OEW+6L70krltbGyTJH30o3fok598VJLU1LRYixZlf6+qq5O2bpUcRzp3TurtlW6/Xdqxwxxvb2+XJA0MDEiSurqkkyelVauk9nZzv6vLwh8MZY9sh1Pki+70tLlNJBK6eLFfx48f0aFD/zd1fHy88O9t2SI9+KD0wAMq+LWrra1NXV1SVdWgJOmZZz6r3bs/LElavpxwwn9kO5wivzhi0ybzCd3ZacK4dOl2fexj21PH6+uv/bXb2qSKihZJ0m9+8wutWfORrGOAn8h2OEW+p9vRYW5HRkbyjp0+XdxrZ57xffTRI/rwhzcVPAb4gWyHU+SLrmR6BLW1jVnPnT4t7dpV3OuOjKQDv3z5Kt16632SJNd1NTAwVdyLA/NAtsOnLKaMXbhwQStWrJDrmnGu+X7t6uqSamulxkYTfQcj5gAAGedJREFUwvXrpXXr0sd/+cuE3nuv8Md+R4e0dq05KdE2y/exnh6zBLOyUursLDy+VgaYMlYEsl3SCma7LIrutejqMicNCvn4xydVU1MjSTp8uPDPbN2a/XhwcFAtLWaMLBYrvN49FkufSS4jFF3LyLY1BbMd+RNpvb29qakw89XTY0L5zjuH9M47h/TAA8+orm6JRkZG1NLSkgqllA7g2JiZM+nMUkKSoZyamtKRIxWqrTUjOzt2NOjWW+/Xgw9+TXV10tRU2fYKsEBkO5wiP6a70FBK0ltvmdubb75TktTQ0Kzt22tS4Sr05aC+fvZQZqqqqlJt7SINDZnpOAcOXNYf/MFXU8d/9KMFNxdlimyHU6SL7oULFwo+n7lWvdAqm+T8R/OzcUnSoUPTOnXq55Jmn/84H8mNR5qbTci/853/Iycj0Ww8gvkg2+EVqeGFzMH7O+8c1ooVK/J+JjmelewknDwpvf22tHNn+mfWrx9QX585QfBHf/Tt1PNr1qyXVNz8xyVLsh+fP5/9L2PVqmt/bUQX2Y6OSPR0Y7H8JYs/+UlT3sqZZCgffthcvfWP//g2/fmf36Xly6WvfW1Mly5dkiTddFOb+vr8a2/mHMqHH345488xri1b/HtfhA/Zjp5IFN2jR03gkht/vPvu/5OUv2QxObvl6afNZZX/9E/f1G/9lvmEv+66erW0tKZ+dudOqa/PTKeRzG1HR/6Z22uxa1f+5PV4XNq6dbHOnTtX/BsgMsh29IR+eMF1ldquLrnxx003/Y/U8crKYfX3m7GreLxBdRkXg+rre1/33POIJLPKJneeY+bXMq8lJ6/nnhmuq/uAJDMJ3ZnP2QtEFtmOptAX3cuXsx8PDw+rqakp9bi1tUnLlpn7U1Nmp6U77kj/hdfW1uvAgcsaGSluPOtazfae5RxKGGQ7miKxOCI5ibvQJ+jIiHTvveb+iRPSqVOFXyO5yqbUTE9Pq7LSfDZGdJUPiyPmQLZDLbqbmCfHkAp9gm7YkL6fXOZ4ZaZMllIMpSRVVlbqvfd6806mvP66dOBA0K2D38h29ESipytJP/hBImvT5njcjIfNdnJgoWvVg3TwYHpsb+fOG/TUU/+stjYz/6avz9/xOQvo6V4F2Q6taC8D3rbNhPJqSxaTHCccocw8mSJJjY1L9ZWv7NBTT/2TJPY2LQdkO1pCP7wwNjaW9Xi+SxbDIneFkOMsyvqqyd6m0UW2LTfIklD3dGdmZlQfho/0IuT+8Z5++qfKHBIqsH81IoBsRzfboe7pLloU6ubPW+5kc8dxFIuZbkLmyRREB9mObrZDcyItdzxrZmambIIp5e9tGo9L69ef12//9spgGuSdsj+RRrazH0c92yVfdAttpDw8PKT77mu235gSkPsPNB6PqzrzbET4lG3RJdvZyiXbJf1xeuJE/nOjo6NqamrWyZP221MKck+mVFdXpzYzQXiQ7Xzlku1Ai25y78/nn5eOHMk//vbb5ja52ceZM7/W7t03SkpvxgyptbVViUQi6GYgA9n2RhSzHdjshf37zVeJ5N6frmu+bm3aZNaQS9Lq1eY2udlHVVW1Kiurs47BqIjq/JoQItveilq2A+npxuMmlO+8c0iS1Nv7XurY0aPpn7t0aViJREKJREKXLg2ourpWMzPmUy9iH36+GBsrfPkV+Ids2xHmbAdyIm3fvnQvQJJiscvq7z+v5uZ2NTY2assWM7aTedXS3B2WIrBE0Beu62rvXkfXX59+Lh6XNm9O97JKTKROpJFt/0Ql24H0dJPXaYrHJxSPT+j06V+publVjY2NktIrVZKbLUsilPP07LOOli2LSZI6O1fqjTf2qbra7OBUridobCLb/olKtgMpups2mdvq6lpVV9fqxhtvSo1tSfmbLa9bZy5q19tr7hPK2V13nVKbWd988yd19Oje1LGf/SyoVpUPsu2fqGQ7kBNpHR2zfzLlrlCRpDVrzH+YW85Sfd111xM6cOCx1OMrnS34iGz7I0rZDmzK2KZN+Xt/nj6dvtRHpv7+fjuNCrnFi7Mf797doTVrPqKhoUFJs5+g6ekxl+zet89cgQDFIdvei1K2A1+R5rrmsiS5l2/O1N/fr2XJ65JgTpn7k+bq65O2bbuopUuXSjJXmj12LP/nYjFpxw4fG5ktUifSst6AbHsqKtkOfEWa48wdSkmEcgE2by78fCxmxguToezt7c2awrRz5w06ftxcabaurnR6BWFGtr0VlWwH3tOdy5Ej5iTDqlXSli1BtiR8Tp2S3nxz9mtOua75/zs5OamJiQk1NTVp+/ZaHTw4Icmc2HngAStNjWxPdy5k+9qFPdsluZ9uckWPJH3gA4VX9GBuyRM0/f39qqrK700lpy7V1NSopqZGf/3X96dCKaWnPsFbZLt4Yc924MMLhWQOmo9k7GT8jW8E0JiIyt1A+sc//o7uuqsh9ZilqP4g2/4r9WyX3PDCkSPZy/t27GjUgQPpcDoOX8cWYq7t8fbsUdbqnkyzXfTQB2UzvEC2vRXWbJdcT/fs2ezH09MTcx7H3Obaj3TXrvy5o8PDsdQEf3iLbHsrrNkuuTHdVatMb+COO8yHxN/8zb9p16512rPnROo4vJOcO5reQLpO4+PjkhbP+XtYOLJtV6lmu+SGF6TCO+pLs08wR6iVzfCCRLbLTDiGFyQz766Qz33ObjuiYmbGzVtGeTVR3LG/FJBtb4Ux2yXZ001iLmNxYjGzh2sslt46cCE9qnffHVVPzxI1NprLYa9fbzZl8VhZ9XSTyHZxwpztki66KE7yq+zw8LA+97n21FzF+YQzc7/XTD5sPViWRRfFCXO2S3J4AcXLvC5XVZWj7du/nHo821SapJ6edCjHxsZS1/GSzPOnTnnZUmBhwp5tim5EZU4/6uxcqUOH/lJ/+IcbUs+Njs7+u5kbhdTX16u+PvuS4G++6VUrgYULe7ZLbsoYvJGcniRJr7wypqGhQTU3t6SOz7URS2VOKiYnJ5VITKuiorLgccCmsGebMd2ImpqSXn+98LF4XNq+ffbf7enJ3oh7cnJSNTU1qcfr1nm68TZjuliQsGeb4YWIqqrKn540PDwsafYt8pI6OtLX75KUFcq+Pq50gGCFPdv0dCNuakr65jfNzkqrVy9setKJE9LPf67UtJoNG6S1az1vIj1dXJOwZpuiW2Z6e3vVnnmN8OBRdOGJsGSboougUXQRVYzpwujt7Q26CYAvwpBterplqqfHzFmsrJRuucWcYAgIPV14qtSzTdEtQ11dUlPTZN6Z28wlkF1dUm2tJI1IavRrbbpE0YWHwpBthhfKTHLdeU1NjbZvr9VDD90oyTzX1ZX9M42Nkuu6amw0yyNn25YQKAVhyTZFt8y0taXv19Ut0ec//3zWscy16ZI0MXFZp0//KvWYfRdQqsKSbYpumamoSN//27/t18GDX0k9Hhsb0aFDoxoeHtbw8LD+9V/fUkvLMj33XHrbJvZdQKkKS7YpumUm4wK0uvvuJdq27eGMo41qaFiipqYmNTU16YMf/Kiqq6t14403W28nsFBhyTYn0srMiROzf43q6DBLLDPXpufyeG26xIk0eCQs2aanW2bmOku7dm3+2vRc7LuAUhWWbNPTLWPpq6TmH0tOq/F5bbpETxc+KOVsU3QRNIouoorhBQAIGkUXACyyduGVjRs32norWNbd3R10EwJFtqPLj2wzpougMaaLqGJMFwCCRtEFAIsougBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYNHVNrwJal084DeyjUDQ0wUAiyi6AGARRRcALKLoAoBFFF0AsIiiCwAWUXQBwCKKLgBYRNEFAIsougBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYBFFFwAsougCgEUUXQCwiKILABZRdAHAIoouAFhE0QUAiyi6AGARRRcALKLoAoBFFF0AsIiiCwAWUXQBwCKKLgBYRNEFAIsougBgEUUXACyi6AKARRRdALCIogsAFlF0AcAiii4AWETRBQCLKLoAYBFFFwAsougCgEUUXQCwiKILABZRdAHAIoouAFhE0QUAiyi6HnAcp9VxnFcdxxlzHOd9x3H+Z9BtAorlOM4XHMfpdhxn0nGcF4NuT1RUBt2AiNgjKS6pXdJ/kfRDx3F+4brur4JtFlCUc5KelPQJSXUBtyUyHNd1g25DqDmOUy9pUNLvuK776yvPvSzprOu6Xw60cYAHHMd5UtJq13U/G3RbooDhheJ9UNJ0suBe8QtJHwqoPQBKGEW3eA2SRnKeG5a0JIC2AChxFN3iXZbUmPNco6TRANoCoMRRdIv3a0mVjuP8p4zn/rMkTqIByEPRLZLrumOSvi/pCcdx6h3H+a+Stkl6OdiWAcVxHKfScZxaSRWSKhzHqXUchxlPRaLoeuPzMlNq+iR9R9JDTBdDBDwmKSbpy5Luu3L/sUBbFAFMGQMAi+jpAoBFFF0AsIiiCwAWUXQBwKKrTf/gLBv85gT0vmQbfiuYbXq6AGARRRcALKLoAoBFFF0AsIiiCwAWUXQBwCKKLgBYRNEFAIsougBgEUUXACyi6AKARdYuvbFx40ZbbwXLuru7g25CoMh2dPmR7atdOYJNQeA3NrxBVLHhDQAEjaILABZRdAHAIoquD8bGJC6yjCgi28WzNnuhHOzZI11/ffpxPC5t3izV1QXXJsALZNs7zF7wyN690nXXFT7W0SGtXWu3PSHC7IUSR7avGbMX/JQbyh07GlL333rLblsAL5Ftb1F0PTA2lv/cV7/6y9T91astNgbwENn2HkXXA4sXp+9funRJJ0/+s5qbV6aeSyQCaBTgAbLtPU6kecBxpL6+QS1f3qLW1la1tn4s6/jAQEANA4pEtr3HibQiua4rx3EUi0nHjuUfj8Wk224bVEtLi/3GhQMn0koU2S5awWxTdIvQ39+vZcuWZT136pT05ptSZaXU2SlVVQXUuPCg6JYgsu0Jiu5C9PSkP903bTJTY5JmZmY0OjqqpqamBb3m1NSUqkhqLoquZWTbGorufHV1ScuXZz/X1yft3CkNDAyora2tqNdPfm2DJIquVWTbKubpzkdmKH/84+/qrrvqJUm1tSPq6lLRoZQkx3HU29ub9zxLLOEnsl0amL2QIzN3fX3vqaGhRa7rqrGxUfX13r1Pe3t76v7hw4V/ZutW794PINulgaKbo6Iifb+2tlkvvHCm4DGvnDghXb58WQ0NDXnHTp6c3xJL00sx7TtzRnrwQWkR32GQg2yXhpA333sjI+n7v/nNz/SZz6woeMwrb78tNTQ0aGpqSs8881nt3v3h1LH5LLHcv998ZUz+o1m9WnrhBTOdB8hEtksDRTfH+vXp+7t3f10vvXQh9XjDBu/fL7mMsqqqSqdO/Vxr1nwk79hsurrSK4YeffS/6yc/eVWSCerRo963FeFGtksDRTfHunXmdnh4OO+YH7spZS6jvOmmT2p8fLjgMdd11d/fn/pvYmIia4zuySf/TkeP7k09rq7mxAWyke3SwJhuAWaQvym12YeXJxlyDQykzyhv3frFrPmRmUssHcfJm6yeOQ7nOI4mJ7N3Jxkf97ftCB+yHTx6unOor/f/L3bnTjNPUpIqMpKWnDs5lzNnsh8/8sgPsx6HNZTwH9kODosjCujr69Py3BnkPstcYvm7vyutWXP135mZMScWZmtqSKblsDjCIrJtFSvS5itMq2piMXNiobraPB4aGlJzc3NYQilRdK0i21ZRdKPMdUM7zkXRxZyilm3GdHP0JQehQsZx0qEstAwTINulgZ5uRE1PT6uyMhSTU+jpYkHCnm16uhmu8gHkq/7+fk9fr8KPdZ0ILbJdOii6GS5duhR0Ezxj5jZOBt0MlAiyXToouhm82NqulIyPjwfdBJQIsl06GNO9Ioj5i5DEmK7vyHZgmDJWjkZGRtTY2Bh0M+ZC0cU1CWu2KbqSJicnVVNTE3QzyhVF10dkO1ClOXvBdaXR0WDbMDMzE2wDfHb58uWgm1CWyLb/wpjtQHu6mbvCj4yY/T6T28+hbESyp0u2oVIbXih0VdIkm2ur4/G4qpOLuwMyNjamep/XOPb29mp0tF3HjpmNRzo7pRK5Ynbkii7ZTiPb+QIZXujpMaF8551DkqSpqbg6O1dae/94XNq3T3ruOenf/33a2vvOxu/pL7GY9C//0q7u7jGtWiW1t0uvvy4dOODr25Ylsp2NbOcLpOgeO2Zub775TklSVVW1Fi1KrzIZGyv0W97o6pJ+9CPzl7NqlfT++4vV1eXf+5WC5OVN6uvr9fDDG1PP19VJU1MBNSqiyLZdYcx2IEU3uWw6Hp9QPD4hySxTTA51JK+N5LXMr32PPHKLhoaGJJnnggxn7q75XnLd9NZ4kvTEE29lHf/mN6/+GmNj4b48ik1kOxvZzhfIrhGdneYrQHV1beq5F188q0uXLqmhoVV+bfeZuSins/MrOn78B7r11s7UMdeVb+8dlNxvdzU1NZqamtL4+Liampo0Pcc30MOHsx/H4ybkIdrP1DqybU9Ysx1IT7eqKn0Zj0ytra2KxYZ8e9/MfTLa22/Uhg13ZB0L4eyTq8o8hzEwMKDt26u1fXt16npVS5YMFVyXnxtKKd2riPgspKKQbXvCmu3A5ukmr5+UvCroyIjU0SHdd1+zb5tz/Md/pK9G2tzcrJaWFknS4OCgRkakJUt8eds52ZjHefq0uW1ra9Nrr7l67bX096l7721Wa2tr6nF/f3/e3M6nnrpb99yTvqjg88/7296wI9sG2S6spFekeTXdZHBwUC0tLTpxwlyvqZCODqml5YJWrFhR9PtdTe5lSCQTnl27/HvPPXuk669PP47Hpc2bzQmHXGNj0t//vbk/PDyshoYGHTv2DX3iE/8r9TMefg2L3JSx+SDb3glbtku66ErS+fPntXKlmXITj0tvvCGdPWvOzm7ZMvvv9fb2qr29Pe/5w4fT4zeZMv9HX7jgb0Azv97cfXej9u8fkeR9OAtdD2tszJzMmWt8z3WlI0fSj//iLz6t48eP6rvfNb2pREK6807PmlmWRVci28UIc7ZLvuhKZpL3q69WFzzzu2lT+hNtcnJSFRUV89pVfj7XXfJjQ40jR7LPln7qU4v18st9qqtrkOTdp2yxa+4PHsz/x5s0n0toL0DZFl2JbF+LsGc78L0X5seE8otf3KhnnvmsJPMXKpmvMgMDA5LM2cv5XsYj87pLs0mGMve6TF1d0re+ZT7Vv/Ut6cSJ+f9Jzp41t8PDwxoeHtYrr4ypq+tLqeNejIMNDQ0VvcnJ5s2FTwh5HEqQ7QWJQrZDUXTfeMPcPv30T5VIJPT661/X9743rhMn3lV1tf8bNLe3t6fCuX+/mfuY7CQ0NpqxtFjs6q9jBvLNjG1zhjWue+5p0he+8KympqYUi8XU0FBcWy9evKjm5ubiXkSmh3X//dKZM+ZxImFCef/9Rb80MpDt+YtKtkNRdJOfoI7jqKKiQj09xyVJQ0Pm/5qNs6Tt7e2Kx6XJycHUc48//vHU/eTKGElKJBIFz5QuW7ZMDzyQXhTe1LQsNeZVVVWlioo6OY4Zr7p48eKsbZmZkZ591vRGDh8292dmpLNnz2rp0qXF/lFTFi2SHnrIfC28807TC1gUisSEB9nOVg7ZDsWYbnKs6I47zBDJa6+5+tSn6vS975mPYFuT9fftM0ssJWloaFDNzS2amJjQ5OSkmpqatGXL/CagHzhQ+Mxq5hheUiwWk+u6Wnxl0G9mRvrhD/N/d2hoUPfe2xLGoljWY7pku/yyHYo/RvJM7muvuTpwwIQxGcrkPD0bMle41NXVaHDwgiYnR1OTsee7t8eOHdLtt5sQnztnbrduLRzWurq6VChd19Vf/VV6lntv73v66U+PaGxsTM3NLcyfDSGyXX7ZDkVPVzLjSt/+9qCWL29JPef3/L9cPT3SyZOzH7fRK0lOyZmYmJDjOHriic36sz/7O6tt8FhZ93Qlsp1ULtkORU9XMp+Un/lMS9YnqM1QSmaS+Wxs9kokqba2Vs8997/1+ONHrv7DKGlkO1vUsx2anu7Q0JAnZy6LFcSKm0zPPiutXl342Jkz5uRAyJR9T5dsG+WS7dAU3VI0Omp/TftsJxsk6fd+L5SzC8q+6JYisu2J8A4v+LVJSLGC2ERk0SITwOQcQ8ncD2koyx7ZTiuXbNPTRdDo6SKqwtnTnWsiNRBmZLs8lXxPN5FIqCJzh2ZETdn2dMl25IXvRFqh7dsQOWVZdMl2WQjf8MJVPhCA0CLb5atki24ikdCiKJ2yBK4g2+WtpP7mXdfs/i6JUCJSyDaSArkEe67clTAjIyMaGmq0vhQS8BrZRq7AT6TNzEgvvGA2Ty4khJtcYGEieyKNbJe90jyR9vzzJpR795qF1efPv68/+ZPbA24VUDyyjUICL7rJDS4aG81lSVauvEE7djyaOp4cBwPChmyjkMCLbiKRvE0okZjWq6/+pT70of+WOl7oKqlAGJBtFBL4mG5X1+xjXvG4tH273y1AwCI7pku2y15pjunef3/hyyFLs1+bHggDso1CAu/pJnV1SW1tUkWF2c7tlluktWttvTsCFNmebhLZLlvh23sBZSHyRRdlqzSHFwCgnFB0AcAiii4AWETRBQCLrG14s3HjRltvBcu6u7uDbkKgyHZ0+ZFtZi8gaMxeQFQxewEAgkbRBQCLKLoAYBFFFwAsougCgEUUXQCwiKILABZRdAHAIoouAFhE0QUAiyi6AGDR1Ta8CWpdPOA3so1A0NMFAIsougBgEUUXACyi6AKARRRdALCIogsAFv1/4kGE4aLmT7YAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x2160 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learner.show_results(ds_type=DatasetType.Train, rows = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from fastai.train import Interpretation\n",
    "a = Interpretation.from_learner(learner,DatasetType.Valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.return_types.topk(\n",
       "values=tensor([0.8261, 0.8253, 0.8253, 0.8252, 0.8252, 0.8252, 0.8219, 0.8204, 0.8199,\n",
       "        0.8187, 0.8184, 0.8183, 0.8177, 0.8176, 0.8176, 0.8167, 0.8159, 0.8153,\n",
       "        0.8140, 0.8134, 0.8125, 0.8120, 0.8106, 0.8098, 0.8085, 0.5907, 0.5837,\n",
       "        0.5831, 0.5830, 0.5811, 0.5811, 0.5802, 0.5784, 0.5783, 0.5780, 0.5766,\n",
       "        0.5764, 0.5764, 0.5757, 0.5754, 0.5753, 0.5745, 0.5740, 0.5740, 0.5732,\n",
       "        0.5732, 0.5732, 0.5731, 0.5731, 0.5731, 0.5719, 0.5719, 0.5719, 0.5719,\n",
       "        0.5719, 0.5719]),\n",
       "indices=tensor([41, 20, 25, 49, 19, 21, 48, 11, 47, 31, 28, 32, 35, 23, 30, 53, 14, 15,\n",
       "        42, 54, 33, 18, 10,  9, 22, 46,  5, 55, 34,  1, 24,  3, 45, 26, 13,  4,\n",
       "        17, 39, 27,  6,  8,  7, 12, 50,  0, 43, 52, 29, 51, 38, 36, 44, 37, 40,\n",
       "         2, 16]))"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.top_losses()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "liangjiaxi",
   "language": "python",
   "name": "liangjiaxi"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
